﻿using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Web;
using System.Windows.Forms;
using FluorineFx.Context;
using Neturion.Dados;
using Neturion.Negocios;
using Neturion.Utils;
using Neturion.Utils.GerenciamentoBoletos;
using Neturion.Utils.TratamentoErros;

namespace Neturion.Fachadas
{
    public class Fachada
    {
        #region Atributos
        private NegocioUsuario _negocioUsuario;
        private NegocioTipoReferenciaPessoa _negocioTipoReferenciaPessoa;
        private NegocioTipoRegistro _negocioTipoRegistro;
        private NegocioUnidadeFederativa _negocioUnidadeFederativa;
        private NegocioAgencia _negocioAgencia;
        private NegocioAssunto _negocioAssunto;
        private NegocioBairro _negocioBairro;
        private NegocioBanco _negocioBanco;
        private NegocioCargo _negocioCargo;
        private NegocioCidade _negocioCidade;
        private NegocioCliente _negocioCliente;
        private NegocioCnae _negocioCnae;
        private NegocioConta _negocioConta;
        private NegocioContaBanco _negocioContaBanco;
        private NegocioEmail _negocioEmail;
        private NegocioEmpresa _negocioEmpresa;
        private NegocioEndereco _negocioEndereco;
        private NegocioFornecedor _negocioFornecedor;
        private NegocioFuncionario _negocioFuncionario;
        private NegocioLogradouro _negocioLogradouro;
        private NegocioMidia _negocioMidia;
        private NegocioMotivoProtocolo _negocioMotivoProtocolo;
        private NegocioNeturionLog _negocioNeturionLog;
        private NegocioObservacao _negocioObservacao;
        private NegocioOperadoraTelefone _negocioOperadoraTelefone;
        private NegocioOrgaoExpedidor _negocioOrgaoExpedidor;
        private NegocioPais _negocioPais;
        private NegocioPerfil _negocioPerfil;
        private NegocioPessoa _negocioPessoa;
        private NegocioProcedimento _negocioProcedimento;
        private NegocioProcedimentoSituacaoTramite _negocioProcedimentoSituacaoTramite;
        private NegocioProduto _negocioProduto;
        private NegocioProtocolo _negocioProtocolo;
        private NegocioProtocoloProcedimento _negocioProtocoloProcedimento;
        private NegocioRamoAtividade _negocioRamoAtividade;
        private NegocioReferenciaPessoa _negocioReferenciaPessoa;
        private NegocioRegistro _negocioRegistro;
        private NegocioSetor _negocioSetor;
        private NegocioSituacaoTramite _negocioSituacaoTramite;
        private NegocioTelefone _negocioTelefone;
        private NegocioTipoAssunto _negocioTipoAssunto;
        private NegocioTipoContaBanco _negocioTipoContaBanco;
        private NegocioTipoLogradouro _negocioTipoLogradouro;
        private NegocioTipoMidia _negocioTipoMidia;
        private NegocioTipoMotivo _negocioTipoMotivo;
        private NegocioCbo _negocioCbo;
        private NegocioArquivo _negocioArquivo;
        private NegocioSistema _negocioSistema;
        private NegocioSistemaPerfil _negocioSistemaPerfil;
        private NegocioSistemaPerfilUsuario _negocioSistemaPerfilUsuario;
        private NegocioTela _negocioTela;
        private NegocioTelaAcao _negocioTelaAcao;
        private NegocioTelaAcaoUsuario _negocioTelaAcaoUsuario;
        private NegocioConfiguracaoSistema _negocioConfiguracaoSistema;
        private NegocioTipoProtocolo _negocioTipoProtocolo;
        private NegocioTitulo _negocioTitulo;
        private NegocioContaContabil _negocioContaContabil;
        private NegocioTransferencia _negocioTransferencia;
        private NegocioFonteGeradora _negocioFonteGeradora;
        private NegocioLancamento _negocioLancamento;
        private NegocioFormaPagamento _negocioFormaPagamento;
        private NegocioMovimentoFinanceiro _negocioMovimentoFinanceiro;
        private NegocioTipoFormaPagamento _negocioTipoFormaPagamento;
        private NegocioPagamento _negocioPagamento;
        private NegocioTipoContaContabil _negocioTipoContaContabil;
        private NegocioTipoFonteGeradora _negocioTipoFonteGeradora;
        private NegocioCheque _negocioCheque;
        private NegocioSituacaoCheque _negocioSituacaoCheque;
        private NegocioMotivoSituacaoCheque _negocioMotivoSituacaoCheque;

        private GeracaoBoleto _geracaoBoleto;
        #endregion


        #region Construtor

        private Fachada()
        {
            Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR");
            _negocioUsuario = new NegocioUsuario();
            _negocioTipoReferenciaPessoa = new NegocioTipoReferenciaPessoa();
            _negocioTipoRegistro = new NegocioTipoRegistro();
            _negocioUnidadeFederativa = new NegocioUnidadeFederativa();
            _negocioAgencia = new NegocioAgencia();
            _negocioAssunto = new NegocioAssunto();
            _negocioBairro = new NegocioBairro();
            _negocioBanco = new NegocioBanco();
            _negocioCargo = new NegocioCargo();
            _negocioCidade = new NegocioCidade();
            _negocioCliente = new NegocioCliente();
            _negocioCnae = new NegocioCnae();
            _negocioConta = new NegocioConta();
            _negocioContaBanco = new NegocioContaBanco();
            _negocioEmail = new NegocioEmail();
            _negocioEmpresa = new NegocioEmpresa();
            _negocioEndereco = new NegocioEndereco();
            _negocioFornecedor = new NegocioFornecedor();
            _negocioFuncionario = new NegocioFuncionario();
            _negocioLogradouro = new NegocioLogradouro();
            _negocioMidia = new NegocioMidia();
            _negocioMotivoProtocolo = new NegocioMotivoProtocolo();
            _negocioNeturionLog = new NegocioNeturionLog();
            _negocioObservacao = new NegocioObservacao();
            _negocioOperadoraTelefone = new NegocioOperadoraTelefone();
            _negocioOrgaoExpedidor = new NegocioOrgaoExpedidor();
            _negocioProcedimentoSituacaoTramite = new NegocioProcedimentoSituacaoTramite();
            _negocioPais = new NegocioPais();
            _negocioPerfil = new NegocioPerfil();
            _negocioPessoa = new NegocioPessoa();
            _negocioProcedimento = new NegocioProcedimento();
            _negocioProcedimentoSituacaoTramite = new NegocioProcedimentoSituacaoTramite();
            _negocioProduto = new NegocioProduto();
            _negocioProtocolo = new NegocioProtocolo();
            _negocioProtocoloProcedimento = new NegocioProtocoloProcedimento();
            _negocioRamoAtividade = new NegocioRamoAtividade();
            _negocioReferenciaPessoa = new NegocioReferenciaPessoa();
            _negocioRegistro = new NegocioRegistro();
            _negocioSetor = new NegocioSetor();
            _negocioSituacaoTramite = new NegocioSituacaoTramite();
            _negocioTelefone = new NegocioTelefone();
            _negocioTipoAssunto = new NegocioTipoAssunto();
            _negocioTipoContaBanco = new NegocioTipoContaBanco();
            _negocioTipoLogradouro = new NegocioTipoLogradouro();
            _negocioTipoMidia = new NegocioTipoMidia();
            _negocioTipoMotivo = new NegocioTipoMotivo();
            _negocioCbo = new NegocioCbo();
            _negocioArquivo = new NegocioArquivo();
            _negocioSistema = new NegocioSistema();
            _negocioSistemaPerfil = new NegocioSistemaPerfil();
            _negocioSistemaPerfilUsuario = new NegocioSistemaPerfilUsuario();
            _negocioTela = new NegocioTela();
            _negocioTelaAcao = new NegocioTelaAcao();
            _negocioTelaAcaoUsuario = new NegocioTelaAcaoUsuario();
            _negocioConfiguracaoSistema = new NegocioConfiguracaoSistema();
            _negocioTipoProtocolo = new NegocioTipoProtocolo();

            _negocioTitulo = new NegocioTitulo();
            _negocioContaContabil = new NegocioContaContabil();
            _negocioTransferencia = new NegocioTransferencia();
            _negocioFonteGeradora = new NegocioFonteGeradora();
            _negocioLancamento = new NegocioLancamento();
            _negocioFormaPagamento = new NegocioFormaPagamento();
            _negocioMovimentoFinanceiro = new NegocioMovimentoFinanceiro();
            _negocioTipoFormaPagamento = new NegocioTipoFormaPagamento();
            _negocioPagamento = new NegocioPagamento();
            _negocioTipoContaContabil = new NegocioTipoContaContabil();
            _negocioTipoFonteGeradora = new NegocioTipoFonteGeradora();
            _negocioCheque = new NegocioCheque();
            _negocioSituacaoCheque = new NegocioSituacaoCheque();
            _negocioMotivoSituacaoCheque = new NegocioMotivoSituacaoCheque();

        }

        #endregion
        

        #region GetInstancia

        public static Fachada GetInstancia()
        {
            return Nested.SessionManager;
        }

        #endregion


        #region Nested

        private class Nested
        {
            static Nested()
            {
            }

            internal static readonly Fachada SessionManager = new Fachada();
        }

        #endregion

        
        #region Agencia

        public Agencia Inserir(Agencia agencia, Usuario usuarioPermissao)
        {
            Agencia tmpAgencia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpAgencia = _negocioAgencia.Inserir(agencia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpAgencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpAgencia;
        }

        public Agencia Atualizar(Agencia agencia, Usuario usuarioPermissao)
        {
            Agencia tmpAgencia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpAgencia = _negocioAgencia.Atualizar(agencia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpAgencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpAgencia;
        }

        public void Excluir(Agencia agencia, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioAgencia.Excluir(agencia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Agencia> ObterTodosAgencias(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao,
            string codigo, string numeroAgencia, Pessoa gerente, Banco banco, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte,
            DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<Agencia> listaAgencia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaAgencia = _negocioAgencia.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, numeroAgencia,
                                                            gerente, banco, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaAgencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaAgencia;
        }

        public Agencia ObterAgenciaPorId(int id, Usuario usuarioPermissao)
        {
            Agencia agencia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                agencia = _negocioAgencia.ObterPorId(id);
            }
            catch (Exception exception)
            {
                agencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return agencia;
        }

        public IList<Agencia> ObterAgenciaPorNumero(string numero, Usuario usuarioPermissao)
        {
            IList<Agencia> listaAgencia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaAgencia = _negocioAgencia.ObterAgenciaPorNumero(numero);
            }
            catch (Exception exception)
            {
                listaAgencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaAgencia;
        }

        public Agencia ObterAgenciaPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Agencia agencia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                agencia = _negocioAgencia.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                agencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return agencia;
        }

        #endregion


        #region Arquivo

        public Arquivo Inserir(Arquivo arquivo, int chavePai, string nomePai)
        {
            Arquivo tmpArquivo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpArquivo = _negocioArquivo.Inserir(arquivo);

                GerenciamentoArquivo gerenciamentoArquivo = new GerenciamentoArquivo();
                gerenciamentoArquivo.NomePasta = nomePai;
                gerenciamentoArquivo.NomeArquivo = arquivo.NomeArquivoServidor;
                gerenciamentoArquivo.Upload();

                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpArquivo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpArquivo;
        }

        public Arquivo Atualizar(Arquivo arquivo)
        {
            Arquivo tmpArquivo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpArquivo = _negocioArquivo.Atualizar(arquivo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpArquivo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpArquivo;
        }

        public void Excluir(Arquivo arquivo)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioArquivo.Excluir(arquivo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Arquivo> ObterTodosArquivos()
        {
            IList<Arquivo> listaArquivos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaArquivos = _negocioArquivo.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaArquivos;
        }

        public Arquivo ObterArquivoPorId(int id)
        {
            Arquivo arquivo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                arquivo = _negocioArquivo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return arquivo;
        }
    
        #endregion


        #region Assunto

        public Assunto Inserir(Assunto assunto, Usuario usuarioPermissao)
        {
            Assunto tmpAssunto;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpAssunto = _negocioAssunto.Inserir(assunto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpAssunto;
        }

        public Assunto Atualizar(Assunto assunto, Usuario usuarioPermissao)
        {
            Assunto tmpAssunto;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpAssunto = _negocioAssunto.Atualizar(assunto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpAssunto;
        }

        public void Excluir(Assunto assunto, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioAssunto.Excluir(assunto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }
        
        public IList<Assunto> ObterTodosAssuntos(Usuario usuarioPermissao)
        {
            IList<Assunto> listaAssunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaAssunto = _negocioAssunto.ObterTodos(usuarioPermissao);
            }
            catch (Exception exception)
            {
                listaAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaAssunto;
        }

        public Assunto ObterAssuntoPorId(int id, Usuario usuarioPermissao)
        {
            Assunto assunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                assunto = _negocioAssunto.ObterPorId(id);
            }
            catch (Exception exception)
            {
                assunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return assunto;
        }

        public Assunto ObterAssuntoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Assunto assunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                assunto = _negocioAssunto.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                assunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return assunto;
        }

        public IList<Assunto> ObterAssuntoPorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<Assunto> listaAssunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaAssunto = _negocioAssunto.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaAssunto;
        }

        public IList<Assunto> ObterTodosAssuntos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo,
            string descricao, TipoAssunto tipoAssunto, Setor setor, Funcionario funcionario, DateTime? inicioVigenciaDe, 
            DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {

            return _negocioAssunto.ObterTodosAssuntos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao,
                tipoAssunto, setor, funcionario, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
        }

        #endregion


        #region Bairro

        public Bairro Inserir(Bairro bairro, Usuario usuarioPermissao)
        {
            Bairro tmpBairro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpBairro = _negocioBairro.Inserir(bairro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpBairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpBairro;
        }

        public Bairro Atualizar(Bairro bairro, Usuario usuarioPermissao)
        {
            Bairro tmpBairro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpBairro = _negocioBairro.Atualizar(bairro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpBairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpBairro;
        }

        public void Excluir(Bairro bairro, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioBairro.Excluir(bairro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Bairro> ObterTodosBairros(Usuario usuarioPermissao)
        {
            IList<Bairro> listaBairro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaBairro = _negocioBairro.ObterTodos();
            }
            catch (Exception exception)
            {
                listaBairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaBairro;
        }

        public Bairro ObterBairroPorId(int id, Usuario usuarioPermissao)
        {
            Bairro bairro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                bairro = _negocioBairro.ObterPorId(id);
            }
            catch (Exception exception)
            {
                bairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return bairro;
        }

        public IList<Bairro> ObterBairroPorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<Bairro> listaBairro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaBairro = _negocioBairro.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaBairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaBairro;
        }

        public IList<Bairro> ObterTodosBairrosPorCidade(Usuario usuarioPermissao, Cidade cidade)
        {
            IList<Bairro> listaBairro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaBairro = _negocioBairro.ObterTodosBairrosPorCidade(usuarioPermissao,cidade);
            }
            catch (Exception exception)
            {
                listaBairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaBairro;
        }

        public Bairro ObterBairroPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Bairro bairro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                bairro = _negocioBairro.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                bairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return bairro;
        }

        public IList<Bairro> ObterTodosBairrosPorCodigoeCidade(Usuario usuarioPermissao, string codigo, Cidade cidade)
        {
            IList<Bairro> listaBairro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaBairro = _negocioBairro.ObterPorCodigoeCidade(usuarioPermissao, codigo, cidade);
            }
            catch (Exception exception)
            {
                listaBairro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaBairro;
        }

        #endregion


        #region Banco

        public Banco Inserir(Banco banco, Usuario usuarioPermissao)
        {
            Banco tmpBanco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpBanco = _negocioBanco.Inserir(banco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpBanco;
        }

        public Banco Atualizar(Banco banco, Usuario usuarioPermissao)
        {
            Banco tmpBanco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpBanco = _negocioBanco.Atualizar(banco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpBanco;
        }

        public void Excluir(Banco banco, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioBanco.Excluir(banco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Banco> ObterTodosBancos(Usuario usuarioPermissao)
        {
            IList<Banco> listaRetorno;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaRetorno = _negocioBanco.ObterTodos();
            }
            catch (Exception exception)
            {
                listaRetorno = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaRetorno;
        }

        public Banco ObterBancoPorId(int id, Usuario usuarioPermissao)
        {
            Banco banco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                banco = _negocioBanco.ObterPorId(id);
            }
            catch (Exception exception)
            {
                banco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return banco;
        }

        public IList<Banco> ObterBancoPorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<Banco> listaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaBanco = _negocioBanco.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaBanco;
        }

        public IList<Banco> ObterTodosBancos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigoCompensacao, string descricao, DateTime? inicioDeVigenciaDe, DateTime? inicioDeVigenciaAte, DateTime? fimDeVigenciaDe, DateTime? fimDeVigenciaAte)
        {
            IList<Banco> listaRetorno;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaRetorno = _negocioBanco.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigoCompensacao, descricao, inicioDeVigenciaDe, inicioDeVigenciaAte, fimDeVigenciaDe, fimDeVigenciaAte);
            }
            catch (Exception exception)
            {
                listaRetorno = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaRetorno;
        }

        public IList<Banco> ObterBancoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            IList<Banco> bancos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                bancos = _negocioBanco.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                bancos = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return bancos;
        }

        #endregion


        #region Cargo

        public Cargo Inserir(Cargo cargo, Usuario usuarioPermissao)
        {
            Cargo tmpCargo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCargo = _negocioCargo.Inserir(usuarioPermissao, cargo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCargo;
        }

        public Cargo Atualizar(Cargo cargo, Usuario usuarioPermissao)
        {
            Cargo tmpCargo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCargo = _negocioCargo.Atualizar(cargo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCargo;
        }

        public void Excluir(Cargo cargo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioCargo.Excluir(cargo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Cargo> ObterTodosCargos(Usuario usuarioPermissao)
        {
            IList<Cargo> listCargo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCargo = _negocioCargo.ObterTodos();
            }
            catch (Exception exception)
            {
                listCargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCargo;
        }

        public IList<Cargo> ObterCargoPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, String descricao)
        {
            IList<Cargo> listCargo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCargo = _negocioCargo.ObterPorDescricao(inicio, quantidade, quantidadeMinima,descricao);
            }
            catch (Exception exception)
            {
                listCargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCargo;
        }

        public IList<Cargo> ObterPorDescricaoCbo(Usuario usuarioPermissao, String descricao)
        {
            IList<Cargo> listCargo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCargo = _negocioCargo.ObterPorDescricaoCbo(descricao);
            }
            catch (Exception exception)
            {
                listCargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCargo;
        }

        public IList<Cargo> ObterPorCbo(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, Cbo cbo)
        {
            IList<Cargo> listCargo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCargo = _negocioCargo.ObterPorCbo(inicio, quantidade, quantidadeMinima,cbo);
            }
            catch (Exception exception)
            {
                listCargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCargo;
        }

        public Cargo ObterCargoPorId(int id, Usuario usuarioPermissao)
        {
            Cargo cargo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cargo = _negocioCargo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                cargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return cargo;
        }

        public Cargo ObterCargoPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            Cargo cargo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cargo = _negocioCargo.ObterCargoPorCodigo(usuarioPermissao, codigo);
            }
            catch (Exception exception)
            {
                cargo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return cargo;
        }

        public IList<Cargo> ObterTodosCargos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo,
            string cboCodigo, string cboDescricao, string descricao, decimal previsaoSalarialDe, decimal previsaoSalarialAte, decimal salarioAnteriorDe,
            decimal salarioAnteriorAte, decimal percentualUltimoReajusteDe, decimal percentualUltimoReajusteAte,
            DateTime? ultimoReajusteDe, DateTime? ultimoReajusteAte, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte,
            DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<Cargo> listaCargos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCargos = _negocioCargo.ObterTodosCargos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, cboCodigo, cboDescricao,
                                descricao, previsaoSalarialDe, previsaoSalarialAte, salarioAnteriorDe, salarioAnteriorAte, percentualUltimoReajusteDe,
                                percentualUltimoReajusteAte, ultimoReajusteDe, ultimoReajusteAte, inicioVigenciaDe, inicioVigenciaAte,
                                fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCargos;
        }

        #endregion


        #region Cbo

        public Cbo Inserir(Cbo cbo, Usuario usuarioPermissao)
        {
            Cbo tmpCbo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCbo = _negocioCbo.Inserir(cbo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCbo;
        }

        public Cbo Atualizar(Cbo cbo, Usuario usuarioPermissao)
        {
            Cbo tmpCbo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCbo = _negocioCbo.Atualizar(cbo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCbo;
        }

        public void Excluir(Cbo cbo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioCbo.Excluir(cbo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Cbo> ObterTodosCbos(Usuario usuarioPermissao)
        {
            IList<Cbo> listCbo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCbo = _negocioCbo.ObterTodos(usuarioPermissao);
            }
            catch (Exception exception)
            {
                listCbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCbo;
        }

        public IList<Cbo> ObterTodosCbos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, EnumTipoCbo enumTipoCbo, string descricao, Cbo cboAnterior, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<Cbo> listCbo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCbo = _negocioCbo.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, enumTipoCbo, descricao, cboAnterior, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {

                listCbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);

            }

            return listCbo;

        }
        
        public Cbo ObterCboPorId(Usuario usuarioPermissao, int id)
        {
            Cbo cbo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cbo = _negocioCbo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                cbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return cbo;
        }

        public IList<Cbo> ObterCboPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            IList<Cbo> listCbo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCbo = _negocioCbo.ObterPorCodigo(codigo);

            }
            catch (Exception exception)
            {
                listCbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCbo;

        }

        public IList<Cbo> ObterCboPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string descricao)
        {
            IList<Cbo> listCbo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listCbo = _negocioCbo.ObterPorDescricao(inicio, quantidade, quantidadeMinima,descricao);
            }
            catch (Exception exception)
            {
                listCbo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listCbo;
        }
    
        #endregion


        #region Conta Contabil
        public ContaContabil Inserir(ContaContabil contaContabil, Usuario usuarioPermissao)
        {
            ContaContabil tmpContaContabil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpContaContabil = _negocioContaContabil.Inserir(contaContabil, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpContaContabil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpContaContabil;
        }

        public ContaContabil Atualizar(ContaContabil contaContabil, Usuario usuarioPermissao)
        {
            ContaContabil tmpContaContabil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpContaContabil = _negocioContaContabil.Atualizar(contaContabil, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpContaContabil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpContaContabil;
        }

        public void Excluir(ContaContabil contaContabil, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioContaContabil.Excluir(contaContabil, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<ContaContabil> ObterTodosContaContabils(Usuario usuarioPermissao)
        {
            IList<ContaContabil> listaContaContabils;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaContabils = _negocioContaContabil.ObterTodos(usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaContabils;
        }

        public IList<ContaContabil> ObterTodosContaContabils(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao,
                                        EnumTipoConta? enumTipoConta, EnumTipoOperacionalidade? enumTipoOperacionalidade, TipoContaContabil tipoContaContabil)
        {
            IList<ContaContabil> listaContaContabils;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaContabils = _negocioContaContabil.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, enumTipoConta, enumTipoOperacionalidade, tipoContaContabil);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaContabils;
        }

        public ContaContabil ObterContaContabilPorId(int id, Usuario usuarioPermissao)
        {
            ContaContabil contaContabil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                contaContabil = _negocioContaContabil.ObterPorId(id, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return contaContabil;
        }

        public ContaContabil ObterContaContabilPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            ContaContabil contaContabil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                contaContabil = _negocioContaContabil.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return contaContabil;
        }
        #endregion


        #region Cidade

        public Cidade Inserir(Cidade cidade, Usuario usuarioPermissao)
        {
            Cidade tmpCidade;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCidade = _negocioCidade.Inserir(cidade);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCidade;
        }

        public Cidade Atualizar(Cidade cidade, Usuario usuarioPermissao)
        {
            Cidade tmpCidade;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCidade = _negocioCidade.Atualizar(cidade);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCidade;
        }

        public void Excluir(Cidade cidade, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioCidade.Excluir(cidade);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Cidade> ObterTodosCidades(Usuario usuarioPermissao)
        {
            IList<Cidade> listaCidade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCidade = _negocioCidade.ObterTodos();
            }
            catch (Exception exception)
            {
                listaCidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCidade;
        }

        public Cidade ObterCidadePorId(int id, Usuario usuarioPermissao)
        {
            Cidade cidade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cidade = _negocioCidade.ObterPorId(id);
            }
            catch (Exception exception)
            {
                cidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return cidade;
        }

        public IList<Cidade> ObterCidadePorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<Cidade> listaCidade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCidade = _negocioCidade.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaCidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCidade;
        }

        public IList<Cidade> ObterTodasCidadesPorEstado(Usuario usuarioPermissao, UnidadeFederativa unidadeFederativa)
        {

            IList<Cidade> listaCidade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCidade = _negocioCidade.ObterTodasCidadesPorEstado(usuarioPermissao, unidadeFederativa);
            }
            catch (Exception exception)
            {
                listaCidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCidade;
        }

        public Cidade ObterCidadePorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Cidade cidade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cidade = _negocioCidade.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                cidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return cidade;
        }

        public IList<Cidade> ObterCidadesPorCodigoeEstado(Usuario usuarioPermissao, string codigo, UnidadeFederativa unidadeFederativa)
        {
            IList<Cidade> listaCidade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCidade = _negocioCidade.ObterPorCodigoeEstado(codigo, unidadeFederativa, usuarioPermissao);
            }
            catch (Exception exception)
            {
                listaCidade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCidade;
        }

        #endregion


        #region Cliente

        public Cliente Inserir(Cliente cliente, Usuario usuarioPermissao)
        {
            Cliente tmpCliente;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCliente = _negocioCliente.Inserir(cliente);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCliente;
        }

        public Cliente Atualizar(Cliente cliente, Usuario usuarioPermissao)
        {
            Cliente tmpCliente;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCliente = _negocioCliente.Atualizar(cliente);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCliente;
        }

        public void Excluir(Cliente cliente, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioCliente.Excluir(cliente);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Cliente> ObterTodosClientes(Usuario usuarioPermissao)
        {
            IList<Cliente> listaCliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCliente = _negocioCliente.ObterTodos();
            }
            catch (Exception exception)
            {
                listaCliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaCliente;
        }

        public IList<Cliente> ObterTodosClientes(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string nomeRazaoSocial, string apelidoFantasia, string nomeReduzido, string cpfCnpj, Midia midia, EnumTipoPessoa enumTipoPessoa, RamoAtividade ramoAtividade, DateTime? dataNascimentoAberturaDe, DateTime? dataNascimentoAberturaAte, DateTime? cadastroDe, DateTime? cadastroAte, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<Cliente> listaCliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCliente = _negocioCliente.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, nomeRazaoSocial, apelidoFantasia, nomeReduzido, cpfCnpj, midia, enumTipoPessoa, ramoAtividade, dataNascimentoAberturaDe, dataNascimentoAberturaAte, cadastroDe, cadastroAte, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaCliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaCliente;
        }

        public Cliente ObterClientePorCpfCnpj(Usuario usuarioPermissao, string cpfCnpj)
        {
            Cliente cliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cliente = _negocioCliente.ObterPorCpfCnpj(usuarioPermissao, cpfCnpj);
            }
            catch (Exception exception)
            {
                cliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return cliente;
        }

        public Cliente ObterClientePorId(int id, Usuario usuarioPermissao)
        {
            Cliente cliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cliente = _negocioCliente.ObterPorId(id);
            }
            catch (Exception exception)
            {
                cliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return cliente;
        }

        public Cliente ObterClientePorPessoa(Usuario usuarioPermissao, Pessoa pessoa)
        {
            Cliente cliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cliente =_negocioCliente.ObterPorPessoa(usuarioPermissao, pessoa);
            }
            catch (Exception exception)
            {
                cliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return cliente;
        }

        public IList<Cliente> ObterPorRamoAtividade(RamoAtividade ramoAtividade, Usuario usuarioPermissao)
        {
            IList<Cliente> listaCliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCliente = _negocioCliente.ObterPorRamoAtividade(ramoAtividade);
            }
            catch (Exception exception)
            {
                listaCliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCliente;
        }

        public Cliente ObterClientePorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Cliente cliente;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cliente = _negocioCliente.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                cliente = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return cliente;
        }

        #endregion


        #region Cnae

        public Cnae Inserir(Cnae cnae, Usuario usuarioPermissao)
        {
            Cnae tmpCnae;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCnae = _negocioCnae.Inserir(cnae);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCnae;
        }

        public Cnae Atualizar(Cnae cnae, Usuario usuarioPermissao)
        {
            Cnae tmpCnae;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCnae = _negocioCnae.Atualizar(cnae);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpCnae;
        }

        public void Excluir(Cnae cnae, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioCnae.Excluir(cnae);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public Cnae ObterCnaePorCodigo(Usuario usuarioPermissao, string codigo)
        {
            Cnae cnae;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cnae = _negocioCnae.ObterPorCodigo(usuarioPermissao, codigo);
            }
            catch (Exception exception)
            {
                cnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return cnae;
        }

        public IList<Cnae> ObterTodosCnaes(Usuario usuarioPermissao)
        {
            IList<Cnae> listaCnae;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCnae = _negocioCnae.ObterTodos();
            }
            catch (Exception exception)
            {
                listaCnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCnae;
        }

        public Cnae ObterCnaePorId(int id, Usuario usuarioPermissao)
        {
            Cnae cnae;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cnae = _negocioCnae.ObterPorId(id);
            }
            catch (Exception exception)
            {
                cnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return cnae;
        }

        public IList<Cnae> ObterCnaePorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<Cnae> listaCnae;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCnae = _negocioCnae.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaCnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCnae;
        }

        public IList<Cnae> ObterTodosCnaes(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigencia, DateTime? fimVigencia)
        {
            IList<Cnae> listaCnae;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCnae = _negocioCnae.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigencia, fimVigencia);
            }
            catch (Exception exception)
            {
                listaCnae = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCnae;
        }

        #endregion


        #region Conta

        public Conta Inserir(Conta conta, Usuario usuarioPermissao)
        {
            Conta tmpConta;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpConta = _negocioConta.Inserir(conta);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpConta = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpConta;
        }

        public Conta Atualizar(Conta conta, Usuario usuarioPermissao)
        {
            Conta tmpConta;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpConta = _negocioConta.Atualizar(conta);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpConta = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpConta;
        }

        public void Excluir(Conta conta, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioConta.Excluir(conta);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Conta> ObterTodosContas(Usuario usuarioPermissao)
        {
            IList<Conta> listaConta;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaConta = _negocioConta.ObterTodos();
            }
            catch (Exception exception)
            {
                listaConta = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaConta;
        }

        public Conta ObterContaPorId(int id, Usuario usuarioPermissao)
        {
            Conta conta;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                conta = _negocioConta.ObterPorId(id);
            }
            catch (Exception exception)
            {
                conta = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return conta;
        }

        public Conta ObterContaPorNumeroConta(string numeroConta, Usuario usuarioPermissao)
        {
            Conta conta;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                conta = _negocioConta.ObterPorNumeroConta(numeroConta);
            }
            catch (Exception exception)
            {
                conta = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return conta;
        }

        #endregion


        #region Conta Banco

        public ContaBanco Inserir(ContaBanco contaBanco, Usuario usuarioPermissao)
        {
            ContaBanco tmpContaBanco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpContaBanco = _negocioContaBanco.Inserir(contaBanco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpContaBanco;
        }

        public ContaBanco Atualizar(ContaBanco contaBanco, Usuario usuarioPermissao)
        {
            ContaBanco tmpContaBanco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpContaBanco = _negocioContaBanco.Atualizar(contaBanco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpContaBanco;
        }

        public void Excluir(ContaBanco contaBanco, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioContaBanco.Excluir(contaBanco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<ContaBanco> ObterTodosContaBancos(Usuario usuarioPermissao)
        {
            IList<ContaBanco> listaContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaBanco = _negocioContaBanco.ObterTodos();
            }
            catch (Exception exception)
            {
                listaContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaBanco;
        }

        public IList<ContaBanco> ObterTodosContaBancos(
            string numero,
            TipoContaBanco tipoContaBanco,
            string descricao,
            Agencia agencia,
            Pessoa titular,
            Usuario usuarioPermissao
            )
        {
            IList<ContaBanco> listaContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaBanco = _negocioContaBanco.ObterTodos(numero,tipoContaBanco,descricao,agencia,titular,usuarioPermissao);
            }
            catch (Exception exception)
            {
                listaContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaBanco;
        }

        public ContaBanco ObterContaBancoPorId(int id, Usuario usuarioPermissao)
        {
            ContaBanco contaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                contaBanco = _negocioContaBanco.ObterPorId(id);
            }
            catch (Exception exception)
            {
                contaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return contaBanco;
        }

        public IList<ContaBanco> ObterContaBancoPorTipoContaBanco(TipoContaBanco tipoContaBanco, Usuario usuarioPermissao)
        {
            IList<ContaBanco> listaContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaBanco = _negocioContaBanco.ObterPorTipoContaBanco(tipoContaBanco);
            }
            catch (Exception exception)
            {
                listaContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaBanco;
        }

        public IList<ContaBanco> ObterContaBancoPorTitular(Pessoa titular, Usuario usuarioPermissao)
        {
            IList<ContaBanco> listaContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaBanco = _negocioContaBanco.ObterPorTitular(titular);
            }
            catch (Exception exception)
            {
                listaContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaBanco;
        }

        public IList<ContaBanco> ObterContaBancoPorAgencia(Agencia agencia, Usuario usuarioPermissao)
        {
            IList<ContaBanco> listaContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaBanco = _negocioContaBanco.ObterPorAgencia(agencia);
            }
            catch (Exception exception)
            {
                listaContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaBanco;
        }

        public IList<ContaBanco> ObterContaBancoPorNumero(string numero, Pessoa titular, Usuario usuarioPermissao)
        {
            IList<ContaBanco> listaContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaContaBanco = _negocioContaBanco.ObterPorNumero(numero, titular, usuarioPermissao);
            }
            catch (Exception exception)
            {
                listaContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaContaBanco;
        }

        #endregion


        #region Configuração Sistema

        public ConfiguracaoSistema Inserir(ConfiguracaoSistema configuracaoSistema, Usuario usuarioLogado)
        {
            ConfiguracaoSistema tmpConfiguracaoSistema;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpConfiguracaoSistema = _negocioConfiguracaoSistema.Inserir(configuracaoSistema, usuarioLogado);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpConfiguracaoSistema = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpConfiguracaoSistema;
        }

        public ConfiguracaoSistema Atualizar(ConfiguracaoSistema configuracaoSistema, Usuario usuarioLogado)
        {
            ConfiguracaoSistema tmpConfiguracaoSistema;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpConfiguracaoSistema = _negocioConfiguracaoSistema.Atualizar(configuracaoSistema, usuarioLogado);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpConfiguracaoSistema = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpConfiguracaoSistema;
        }

        public void Excluir(ConfiguracaoSistema configuracaoSistema, Usuario usuarioLogado)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioConfiguracaoSistema.Excluir(configuracaoSistema, usuarioLogado);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<ConfiguracaoSistema> ObterTodosConfiguracaoSistemas(Usuario usuarioLogado)
        {
            IList<ConfiguracaoSistema> listaConfiguracaoSistemas;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaConfiguracaoSistemas = _negocioConfiguracaoSistema.ObterTodos(usuarioLogado);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaConfiguracaoSistemas;
        }

        public ConfiguracaoSistema ObterConfiguracaoSistemaPorId(int id, Usuario usuarioLogado)
        {
            ConfiguracaoSistema configuracaoSistema;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                configuracaoSistema = _negocioConfiguracaoSistema.ObterPorId(id, usuarioLogado);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return configuracaoSistema;
        }

        public ConfiguracaoSistema ObterConfiguracaoSistemaPorCodigoSistema(Sistema sistema)
        {
            ConfiguracaoSistema configuracaoSistema;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                configuracaoSistema = _negocioConfiguracaoSistema.ObterPorCodigoSistema(sistema);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return configuracaoSistema;
        }
    
        #endregion


        # region Cheque
        public Cheque Inserir(Cheque cheque)
        {
            Cheque tmpCheque;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCheque = _negocioCheque.Inserir(cheque);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCheque = null;
                throw;
            }
            return tmpCheque;
        }

        public Cheque Atualizar(Cheque cheque)
        {
            Cheque tmpCheque;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpCheque = _negocioCheque.Atualizar(cheque);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpCheque = null;
                throw;
            }
            return tmpCheque;
        }

        public void Excluir(Cheque cheque)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioCheque.Excluir(cheque);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                throw;
            }
        }

        public IList<Cheque> ObterTodosCheques()
        {
            IList<Cheque> listaCheque;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCheque = _negocioCheque.ObterTodos();
            }
            catch (Exception exception)
            {
                listaCheque = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCheque;
        }

        public Cheque ObterChequePorId(int id)
        {
            Cheque cheque;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                cheque = _negocioCheque.ObterPorId(id);
            }
            catch (Exception exception)
            {
                cheque = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return cheque;
        }

        public IList<Cheque> ObterTodosCheques(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, EnumTipoCheque enumTipoCheque,
                                        string numero, Pessoa titular, Pessoa destinatario, ContaBanco contaBanco, DateTime? bomParaDe,
                                        DateTime? bomParaAte, DateTime? emissaoDe, DateTime? emissaoAte)
        {
            IList<Cheque> listaCheque;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaCheque = _negocioCheque.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, enumTipoCheque, numero, titular, 
                                                        destinatario, contaBanco, bomParaDe, bomParaAte, emissaoDe, emissaoAte);
            }
            catch (Exception exception)
            {
                listaCheque = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaCheque;
        }

        #endregion


        #region Email

        public Email Inserir(Email email, Usuario usuarioPermissao)
        {
            Email tmpEmail;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpEmail = _negocioEmail.Inserir(email);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpEmail = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpEmail;
        }

        public Email Atualizar(Email email, Usuario usuarioPermissao)
        {
            Email tmpEmail;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpEmail = _negocioEmail.Atualizar(email);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpEmail = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpEmail;
        }

        public void Excluir(Email email, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioEmail.Excluir(email);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Email> ObterTodosEmails(Usuario usuarioPermissao)
        {
            IList<Email> listaEmail;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaEmail = _negocioEmail.ObterTodos();
            }
            catch (Exception exception)
            {
                listaEmail = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaEmail;
        }

        public Email ObterEmailPorId(int id, Usuario usuarioPermissao)
        {
            Email email;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                email = _negocioEmail.ObterPorId(id);
            }
            catch (Exception exception)
            {
                email = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return email;
        }

        public Email ObterEmailPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Email email;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                email = _negocioEmail.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                email = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return email;
        }

        public IList<Email> ObterEmailPorPessoa(Pessoa pessoa, Usuario usuarioPermissao)
        {
            IList<Email> listaEmail;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaEmail = _negocioEmail.ObterPorPessoa(pessoa);
            }
            catch (Exception exception)
            {
                listaEmail = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaEmail;
        }

        #endregion


        #region Empresa

        public Empresa Inserir(Empresa empresa, Usuario usuarioPermissao)
        {
            Empresa tmpEmpresa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpEmpresa = _negocioEmpresa.Inserir(empresa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpEmpresa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpEmpresa;
        }

        public Empresa Atualizar(Empresa empresa, Usuario usuarioPermissao)
        {
            Empresa tmpEmpresa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpEmpresa = _negocioEmpresa.Atualizar(empresa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpEmpresa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpEmpresa;
        }

        public void Excluir(Empresa empresa, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioEmpresa.Excluir(empresa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Empresa> ObterTodosEmpresas(Usuario usuarioPermissao)
        {
            IList<Empresa> listaEmpresa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaEmpresa = _negocioEmpresa.ObterTodos();
            }
            catch (Exception exception)
            {
                listaEmpresa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaEmpresa;
        }

        public Empresa ObterEmpresaPorId(int id, Usuario usuarioPermissao)
        {
            Empresa empresa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                empresa = _negocioEmpresa.ObterPorId(id);
            }
            catch (Exception exception)
            {
                empresa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return empresa;
        }

        public Empresa ObterEmpresaPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Empresa empresa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                empresa = _negocioEmpresa.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                empresa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return empresa;
        }

        #endregion


        #region Endereco

        public Endereco Inserir(Endereco endereco, Usuario usuarioPermissao)
        {
            Endereco tmpEndereco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpEndereco = _negocioEndereco.Inserir(endereco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpEndereco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpEndereco;
        }

        public Endereco Atualizar(Endereco endereco, Usuario usuarioPermissao)
        {
            Endereco tmpEndereco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpEndereco = _negocioEndereco.Atualizar(endereco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpEndereco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpEndereco;
        }

        public void Excluir(Endereco endereco, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioEndereco.Excluir(endereco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Endereco> ObterTodosEnderecos(Usuario usuarioPermissao)
        {
            IList<Endereco> listaEndereco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaEndereco = _negocioEndereco.ObterTodos();
            }
            catch (Exception exception)
            {
                listaEndereco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaEndereco;
        }

        public Endereco ObterEnderecoPorId(int id, Usuario usuarioPermissao)
        {
            Endereco endereco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                endereco = _negocioEndereco.ObterPorId(id);
            }
            catch (Exception exception)
            {
                endereco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return endereco;
        }

        public Endereco ObterEnderecoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Endereco endereco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                endereco = _negocioEndereco.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                endereco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return endereco;
        }

        public IList<Endereco> ObterEnderecoPorPessoa(Pessoa pessoa, Usuario usuarioPermissao)
        {
            IList<Endereco> listaEndereco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaEndereco = _negocioEndereco.ObterPorPessoa(pessoa);
            }
            catch (Exception exception)
            {
                listaEndereco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaEndereco;
        }

        #endregion


        #region Fonte Geradora
        public FonteGeradora Inserir(FonteGeradora fonteGeradora, Usuario usuarioPermissao)
        {
            FonteGeradora tmpFonteGeradora;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFonteGeradora = _negocioFonteGeradora.Inserir(fonteGeradora, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFonteGeradora = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFonteGeradora;
        }

        public FonteGeradora Atualizar(FonteGeradora fonteGeradora, Usuario usuarioPermissao)
        {
            FonteGeradora tmpFonteGeradora;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFonteGeradora = _negocioFonteGeradora.Atualizar(fonteGeradora, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFonteGeradora = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFonteGeradora;
        }

        public void Excluir(FonteGeradora fonteGeradora, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioFonteGeradora.Excluir(fonteGeradora, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<FonteGeradora> ObterTodosFonteGeradoras(Usuario usuarioPermissao)
        {
            IList<FonteGeradora> listaFonteGeradoras;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFonteGeradoras = _negocioFonteGeradora.ObterTodos(usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFonteGeradoras;
        }

        public IList<FonteGeradora> ObterTodosFonteGeradoras(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao,
                                                            DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<FonteGeradora> listaFonteGeradoras;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFonteGeradoras = _negocioFonteGeradora.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao,
                                                                        inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFonteGeradoras;
        }

        public FonteGeradora ObterFonteGeradoraPorId(int id, Usuario usuarioPermissao)
        {
            FonteGeradora fonteGeradora;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                fonteGeradora = _negocioFonteGeradora.ObterPorId(id, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return fonteGeradora;
        }

        public FonteGeradora ObterFonteGeradoraPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            FonteGeradora fonteGeradora;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                fonteGeradora = _negocioFonteGeradora.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return fonteGeradora;
        }
        #endregion


        #region Forma de Pagamento
        public FormaPagamento Inserir(FormaPagamento formaPagamento, Usuario usuarioPermissao)
        {
            FormaPagamento tmpFormaPagamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFormaPagamento = _negocioFormaPagamento.Inserir(formaPagamento, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFormaPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFormaPagamento;
        }

        public FormaPagamento Atualizar(FormaPagamento formaPagamento, Usuario usuarioPermissao)
        {
            FormaPagamento tmpFormaPagamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFormaPagamento = _negocioFormaPagamento.Atualizar(formaPagamento, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFormaPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFormaPagamento;
        }

        public DateTime CalcularDataVencimentoFormaPagamento(DateTime dataEmissao, FormaPagamento formaPagamento)
        {
            DateTime dataVencimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                dataVencimento = _negocioFormaPagamento.CalcularDataVencimentoFormaPagamento(dataEmissao, formaPagamento);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return dataVencimento;
        }

        public void Excluir(FormaPagamento formaPagamento, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioFormaPagamento.Excluir(formaPagamento, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }
        
        public IList<FormaPagamento> ObterTodosFormaPagamentos(Usuario usuarioPermissao)
        {
            IList<FormaPagamento> listaFormaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFormaPagamentos = _negocioFormaPagamento.ObterTodos(usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFormaPagamentos;
        }

        public IList<FormaPagamento> ObterTodosFormaPagamentos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, TipoFormaPagamento tipoFormaPagamento, EnumTipoMovimentoFinanceiro enumTipoMovimentoFinanceiro)
        {
            IList<FormaPagamento> listaFormaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFormaPagamentos = _negocioFormaPagamento.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, tipoFormaPagamento, enumTipoMovimentoFinanceiro);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFormaPagamentos;
        }

        public IList<FormaPagamento> ObterTodosFormaPagamentos(Usuario usuarioPermissao, string codigo, string descricao, TipoFormaPagamento tipoFormaPagamento, EnumTipoMovimentoFinanceiro enumTipoMovimentoFinanceiro)
        {
            IList<FormaPagamento> listaFormaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFormaPagamentos = _negocioFormaPagamento.ObterTodos(usuarioPermissao, codigo, descricao, tipoFormaPagamento, enumTipoMovimentoFinanceiro);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFormaPagamentos;
        }

        public FormaPagamento ObterFormaPagamentoPorId(int id, Usuario usuarioPermissao)
        {
            FormaPagamento formaPagamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                formaPagamento = _negocioFormaPagamento.ObterPorId(id, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return formaPagamento;
        }

        public FormaPagamento ObterFormaPagamentoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            FormaPagamento formaPagamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                formaPagamento = _negocioFormaPagamento.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return formaPagamento;
        }

        public IList<FormaPagamento> ObterTodosFormaPagamentosPorTipo(EnumTipoFormaPagamento enumTipoFormaPagamento, Usuario usuarioPermissao)
        {
            IList<FormaPagamento> listaFormaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFormaPagamentos = _negocioFormaPagamento.ObterPorTipo(enumTipoFormaPagamento);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFormaPagamentos;
        }
        #endregion


        #region Fornecedor

        public Fornecedor Inserir(Fornecedor fornecedor, Usuario usuarioPermissao)
        {
            Fornecedor tmpFornecedor;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFornecedor = _negocioFornecedor.Inserir(fornecedor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFornecedor;
        }

        public Fornecedor Atualizar(Fornecedor fornecedor, Usuario usuarioPermissao)
        {
            Fornecedor tmpFornecedor;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFornecedor = _negocioFornecedor.Atualizar(fornecedor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFornecedor;
        }

        public void Excluir(Fornecedor fornecedor, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioFornecedor.Excluir(fornecedor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Fornecedor> ObterTodosFornecedors(Usuario usuarioPermissao)
        {
            IList<Fornecedor> listaFornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFornecedor = _negocioFornecedor.ObterTodos();
            }
            catch (Exception exception)
            {
                listaFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFornecedor;
        }

        public IList<Fornecedor> ObterTodosFornecedors(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string nomeRazaoSocial, string apelidoFantasia, string nomeReduzido, string cpfCnpj, Midia midia, EnumTipoPessoa enumTipoPessoa, RamoAtividade ramoAtividade, Cnae cnae, DateTime? dataNascimentoAberturaDe, DateTime? dataNascimentoAberturaAte, DateTime? cadastroDe, DateTime? cadastroAte, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<Fornecedor> listaFornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFornecedor = _negocioFornecedor.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, nomeRazaoSocial, apelidoFantasia, nomeReduzido, cpfCnpj, midia, enumTipoPessoa, ramoAtividade, cnae, dataNascimentoAberturaDe, dataNascimentoAberturaAte, cadastroDe, cadastroAte, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFornecedor;
        }

        public Fornecedor ObterFornecedorPorId(int id, Usuario usuarioPermissao)
        {
            Fornecedor fornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                fornecedor = _negocioFornecedor.ObterPorId(id);
            }
            catch (Exception exception)
            {
                fornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return fornecedor;
        }

        public Fornecedor ObterFornecedorPorCpfCnpj(Usuario usuarioPermissao, string cpfCnpj)
        {
            Fornecedor fornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                fornecedor = _negocioFornecedor.ObterPorCpfCnpj(usuarioPermissao, cpfCnpj);
            }
            catch (Exception exception)
            {
                fornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return fornecedor;
        }

        public IList<Fornecedor> ObterFornecedorPorCnae(Cnae cnae, Usuario usuarioPermissao)
        {
            IList<Fornecedor> listaFornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFornecedor = _negocioFornecedor.ObterPorCnae(cnae);
            }
            catch (Exception exception)
            {
                listaFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFornecedor;
        }

        public IList<Fornecedor> ObterFornecedorPorRamoAtividade(RamoAtividade ramoAtividade, Usuario usuarioPermissao)
        {
            IList<Fornecedor> listaFornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFornecedor = _negocioFornecedor.ObterPorRamoAtividade(ramoAtividade);
            }
            catch (Exception exception)
            {
                listaFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFornecedor;
        }

        public Fornecedor ObterFornecedorPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            Fornecedor fornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                fornecedor = _negocioFornecedor.ObterPorCodigo(usuarioPermissao,codigo);
            }
            catch (Exception exception)
            {
                fornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return fornecedor;
        }

        public Fornecedor ObterFornecedorPorPessoa(Usuario usuarioPermissao, Pessoa pessoa)
        {
            Fornecedor fornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                fornecedor = _negocioFornecedor.ObterPorPessoa(usuarioPermissao, pessoa);
            }
            catch (Exception exception)
            {
                fornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return fornecedor;
        }

        public IList<Fornecedor> ObterFornecedorPorNome(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string nome)
        {
            IList<Fornecedor> listaFornecedor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFornecedor = _negocioFornecedor.ObterPorNome(inicio, quantidade, quantidadeMinima,nome);
            }
            catch (Exception exception)
            {
                listaFornecedor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFornecedor;
        }
        
        #endregion


        #region Funcionario

        public Funcionario Inserir(Funcionario funcionario, Usuario usuarioPermissao)
        {
            Funcionario tmpFuncionario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFuncionario = _negocioFuncionario.Inserir(funcionario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFuncionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFuncionario;
        }

        public Funcionario Atualizar(Funcionario funcionario, Usuario usuarioPermissao)
        {
            Funcionario tmpFuncionario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpFuncionario = _negocioFuncionario.Atualizar(funcionario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpFuncionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpFuncionario;
        }

        public void Excluir(Funcionario funcionario, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioFuncionario.Excluir(funcionario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Funcionario> ObterTodosFuncionarios(Usuario usuarioPermissao)
        {
            IList<Funcionario> listaFuncionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFuncionario = _negocioFuncionario.ObterTodos();
            }
            catch (Exception exception)
            {
                listaFuncionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFuncionario;
        }

        public IList<Funcionario> ObterTodosFuncionarios(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao,
            string codigo, string descricao, string cargoCodigo, string cargoDescricao, string setorCodigo, string setorDescricao, 
            decimal previsaoSalarialDe, decimal previsaoSalarialAte, decimal salarioAnteriorDe, decimal salarioAnteriorAte, 
            decimal percentualUltimoReajusteDe, decimal percentualUltimoReajusteAte, DateTime? ultimoReajusteDe, 
            DateTime? ultimoReajusteAte, DateTime? contratacaoDe,  DateTime? contratacaoAte, DateTime? demissaoDe,
            DateTime? demissaoAte)
        {
            IList<Funcionario> listaFuncionarios;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFuncionarios = _negocioFuncionario.ObterTodosFuncionarios(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao,
                                cargoCodigo, cargoDescricao, setorCodigo, setorDescricao, previsaoSalarialDe, previsaoSalarialAte, salarioAnteriorDe, 
                                salarioAnteriorAte, percentualUltimoReajusteDe, percentualUltimoReajusteAte, ultimoReajusteDe, ultimoReajusteAte, 
                                contratacaoDe, contratacaoAte, demissaoDe, demissaoAte);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFuncionarios;
        }
        
        public Funcionario ObterFuncionarioPorId(int id, Usuario usuarioPermissao)
        {
            Funcionario funcionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                funcionario = _negocioFuncionario.ObterPorId(id);
            }
            catch (Exception exception)
            {
                funcionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return funcionario;
        }
        
        public Funcionario ObterFuncionarioPorCodigo( Usuario usuarioPermissao, string codigo)
        {
            Funcionario funcionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                funcionario = _negocioFuncionario.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                funcionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return funcionario;
        }

        public IList<Funcionario> ObterFuncionarioPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string descricao)
        {
            IList<Funcionario> listFuncionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listFuncionario = _negocioFuncionario.ObterPorDescricao(inicio, quantidade, quantidadeMinima,descricao);
            }
            catch (Exception exception)
            {

                listFuncionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listFuncionario;
        }

        public Funcionario ObterFuncionarioPorCpf(Usuario usuarioPermissao, string cpf)
        {
            Funcionario funcionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                funcionario = _negocioFuncionario.ObterPorCpf(cpf);
            }
            catch (Exception exception)
            {
                funcionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return funcionario;
        }

        public Funcionario ObterFuncionarioPorPessoa(Usuario usuarioPermissao, Pessoa pessoa)
        {
            Funcionario funcionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                funcionario = _negocioFuncionario.ObterPorPessoa(pessoa);
            }
            catch (Exception exception)
            {
                funcionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return funcionario;
        }

        public IList<Funcionario> ObterFuncionarioPorCargo(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, Cargo cargo)
        {
            IList<Funcionario> listaFuncionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFuncionario = _negocioFuncionario.ObterPorCargo(inicio, quantidade, quantidadeMinima,cargo);
            }
            catch (Exception exception)
            {
                listaFuncionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFuncionario;
        }

        public IList<Funcionario> ObterFuncionarioPorSetor(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, Setor setor)
        {
            IList<Funcionario> listaFuncionario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaFuncionario = _negocioFuncionario.ObterPorSetor(inicio, quantidade, quantidadeMinima,setor);
            }
            catch (Exception exception)
            {
                listaFuncionario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaFuncionario;
        }

        #endregion


        #region Lançamento
        public Lancamento Inserir(Lancamento lancamento)
        {
            Lancamento tmpLancamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpLancamento = _negocioLancamento.Inserir(lancamento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpLancamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpLancamento;
        }

        public Lancamento Atualizar(Lancamento lancamento)
        {
            Lancamento tmpLancamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpLancamento = _negocioLancamento.Atualizar(lancamento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpLancamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpLancamento;
        }

        public void Excluir(Lancamento lancamento)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioLancamento.Excluir(lancamento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Lancamento> ObterTodosLancamentos()
        {
            IList<Lancamento> listaLancamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaLancamentos = _negocioLancamento.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaLancamentos;
        }

        public Lancamento ObterLancamentoPorId(int id)
        {
            Lancamento lancamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                lancamento = _negocioLancamento.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return lancamento;
        }
        #endregion


        #region Logradouro

        public Logradouro Inserir(Logradouro logradouro, Usuario usuarioPermissao)
        {
            Logradouro tmpLogradouro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpLogradouro = _negocioLogradouro.Inserir(logradouro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpLogradouro;
        }

        public Logradouro Atualizar(Logradouro logradouro, Usuario usuarioPermissao)
        {
            Logradouro tmpLogradouro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpLogradouro = _negocioLogradouro.Atualizar(logradouro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpLogradouro;
        }

        public void Excluir(Logradouro logradouro, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioLogradouro.Excluir(logradouro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Logradouro> ObterTodosLogradouros(Usuario usuarioPermissao)
        {
            IList<Logradouro> listaLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaLogradouro = _negocioLogradouro.ObterTodos();
            }
            catch (Exception exception)
            {
                listaLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaLogradouro; 
        }

        public IList<Logradouro> ObterTodosLogradouros(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, Cidade cidade, Bairro bairro, TipoLogradouro tipoLogradouro, string descricao)
        {
            IList<Logradouro> listaLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaLogradouro = _negocioLogradouro.ObterTodos(inicio,quantidade,quantidadeMinima,usuarioPermissao,cidade,bairro,tipoLogradouro, descricao);
            }
            catch (Exception exception)
            {
                listaLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaLogradouro;
        }

        public Logradouro ObterLogradouroPorId(int id, Usuario usuarioPermissao)
        {
            Logradouro logradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                logradouro = _negocioLogradouro.ObterPorId(id);
            }
            catch (Exception exception)
            {
                logradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return logradouro;
        }

        public Logradouro ObterLogradouroPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Logradouro logradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                logradouro = _negocioLogradouro.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                logradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return logradouro;
        }

        public IList<Logradouro> ObterLogradouroPorCep(Usuario usuarioPermissao, string cep)
        {
            IList<Logradouro> listaLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaLogradouro = _negocioLogradouro.ObterPorCep(usuarioPermissao,cep);
            }
            catch (Exception exception)
            {
                listaLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaLogradouro;
        }

        public IList<Logradouro> ObterLogradouroPorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<Logradouro> listaLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaLogradouro = _negocioLogradouro.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaLogradouro;
        }

        #endregion


        #region Midia

        public Midia Inserir(Midia midia, Usuario usuarioPermissao)
        {
            Midia tmpMidia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMidia = _negocioMidia.Inserir(midia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMidia;
        }

        public Midia Atualizar(Midia midia, Usuario usuarioPermissao)
        {
            Midia tmpMidia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMidia = _negocioMidia.Atualizar(midia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMidia;
        }

        public void Excluir(Midia midia, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioMidia.Excluir(midia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Midia> ObterTodosMidias(Usuario usuarioPermissao)
        {
            IList<Midia> listaMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMidia = _negocioMidia.ObterTodos();
            }
            catch (Exception exception)
            {
                listaMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaMidia;
        }

        public Midia ObterMidiaPorId(int id, Usuario usuarioPermissao)
        {
            Midia midia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                midia = _negocioMidia.ObterPorId(id);
            }
            catch (Exception exception)
            {
                midia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return midia;
        }

        public Midia ObterMidiaPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            Midia midia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                midia = _negocioMidia.ObterPorCodigo(usuarioPermissao,codigo);
            }
            catch (Exception exception)
            {
                midia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return midia;
        }

        public IList<Midia> ObterMidiaPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string descricao)
        {
            IList<Midia> listaMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMidia = _negocioMidia.ObterPorDescricao(inicio, quantidade, quantidadeMinima, descricao);
            }
            catch (Exception exception)
            {
                listaMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaMidia;
        }

        public IList<Midia> ObterMidiaPorTipoMidia(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, TipoMidia tipoMidia)
        {
            IList<Midia> listaMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMidia = _negocioMidia.ObterPorTipoMidia(inicio, quantidade, quantidadeMinima,tipoMidia);
            }
            catch (Exception exception)
            {
                listaMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaMidia;
        }

        public IList<Midia> ObterMidiaPorFornecedor(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, Fornecedor fornecedor)
        {
            IList<Midia> listaMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMidia = _negocioMidia.ObterPorFornecedor(inicio, quantidade, quantidadeMinima, fornecedor);
            }
            catch (Exception exception)
            {
                listaMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaMidia;
        }

        #endregion


        #region Motivo Protocolo

        public MotivoProtocolo Inserir(MotivoProtocolo motivoProtocolo, Usuario usuarioPermissao)
        {
            MotivoProtocolo tmpMotivoProtocolo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMotivoProtocolo = _negocioMotivoProtocolo.Inserir(motivoProtocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMotivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMotivoProtocolo;
        }

        public MotivoProtocolo Atualizar(MotivoProtocolo motivoProtocolo, Usuario usuarioPermissao)
        {
            MotivoProtocolo tmpMotivoProtocolo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMotivoProtocolo = _negocioMotivoProtocolo.Atualizar(motivoProtocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMotivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMotivoProtocolo;
        }

        public void Excluir(MotivoProtocolo motivoProtocolo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioMotivoProtocolo.Excluir(motivoProtocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<MotivoProtocolo> ObterTodosMotivoProtocolos(Usuario usuarioPermissao)
        {
            IList<MotivoProtocolo> listaMotivoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMotivoProtocolo = _negocioMotivoProtocolo.ObterTodos();
            }
            catch (Exception exception)
            {
                listaMotivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaMotivoProtocolo;
        }

        public IList<MotivoProtocolo> ObterTodosMotivosProtocolos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, TipoMotivo tipoMotivo, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<MotivoProtocolo> listaMotivoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMotivoProtocolo = _negocioMotivoProtocolo.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, tipoMotivo, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaMotivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaMotivoProtocolo;
        }

        public MotivoProtocolo ObterMotivoProtocoloPorId(int id, Usuario usuarioPermissao)
        {
            MotivoProtocolo motivoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                motivoProtocolo = _negocioMotivoProtocolo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                motivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return motivoProtocolo;
        }

        public MotivoProtocolo ObterMotivoProtocoloPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            MotivoProtocolo motivoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                motivoProtocolo = _negocioMotivoProtocolo.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                motivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return motivoProtocolo;
        }

        public IList<MotivoProtocolo> ObterMotivoProtocoloPorTipoMotivo(TipoProtocolo tipoMotivo, Usuario usuarioPermissao)
        {
            IList<MotivoProtocolo> listaMotivoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMotivoProtocolo = _negocioMotivoProtocolo.ObterPorTipoMotivo(tipoMotivo);
            }
            catch (Exception exception)
            {
                listaMotivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaMotivoProtocolo;
        }

        public IList<MotivoProtocolo> ObterMotivoProtocoloPorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<MotivoProtocolo> listaMotivoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMotivoProtocolo = _negocioMotivoProtocolo.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaMotivoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaMotivoProtocolo;
        }

        #endregion


        #region MotivoSituacaoCheque
        public MotivoSituacaoCheque Inserir(MotivoSituacaoCheque motivoSituacaoCheque, Usuario usuarioPermissao)
        {
            MotivoSituacaoCheque tmpMotivoSituacaoCheque;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMotivoSituacaoCheque = _negocioMotivoSituacaoCheque.Inserir(motivoSituacaoCheque, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMotivoSituacaoCheque = null;
                throw;
            }
            return tmpMotivoSituacaoCheque;
        }

        public MotivoSituacaoCheque Atualizar(MotivoSituacaoCheque motivoSituacaoCheque, Usuario usuarioPermissao)
        {
            MotivoSituacaoCheque tmpMotivoSituacaoCheque;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMotivoSituacaoCheque = _negocioMotivoSituacaoCheque.Atualizar(motivoSituacaoCheque, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMotivoSituacaoCheque = null;
                throw;
            }
            return tmpMotivoSituacaoCheque;
        }

        public void Excluir(MotivoSituacaoCheque motivoSituacaoCheque, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioMotivoSituacaoCheque.Excluir(motivoSituacaoCheque, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                throw;
            }
        }

        public IList<MotivoSituacaoCheque> ObterTodosMotivoSituacaoCheques()
        {
            NegocioGerenciadorBD.LimparSessao();
            return _negocioMotivoSituacaoCheque.ObterTodos();
        }

        public MotivoSituacaoCheque ObterMotivoSituacaoChequePorId(int id)
        {
            NegocioGerenciadorBD.LimparSessao();
            return _negocioMotivoSituacaoCheque.ObterPorId(id);
        }

        public IList<MotivoSituacaoCheque> ObterTodosMotivoSituacaoCheques(int inicio, int quantidade, int quantidadeMinima, string codigo, string descricao)
        {
            NegocioGerenciadorBD.LimparSessao();
            return _negocioMotivoSituacaoCheque.ObterTodos(inicio, quantidade, quantidadeMinima, codigo, descricao);
        }

        #endregion


        #region MovimentoFinanceiro

        public MovimentoFinanceiro Inserir(MovimentoFinanceiro movimentoFinanceiro, Usuario usuarioPermissao)
        {
            MovimentoFinanceiro tmpMovimentoFinanceiro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMovimentoFinanceiro = _negocioMovimentoFinanceiro.Inserir(movimentoFinanceiro, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMovimentoFinanceiro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMovimentoFinanceiro;
        }

        public MovimentoFinanceiro AceitarMovimentoFinanceiro(MovimentoFinanceiro movimentoFinanceiro, Usuario usuarioPermissao)
        {
            MovimentoFinanceiro tmpMovimentoFinanceiro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMovimentoFinanceiro = _negocioMovimentoFinanceiro.AceitarMovimentoFinanceiro(movimentoFinanceiro, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMovimentoFinanceiro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMovimentoFinanceiro;
        }

        public MovimentoFinanceiro EstornarMovimentoFinanceiro(MovimentoFinanceiro movimentoFinanceiro, Usuario usuarioPermissao)
        {
            MovimentoFinanceiro tmpMovimentoFinanceiro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMovimentoFinanceiro = _negocioMovimentoFinanceiro.EstornarMovimentoFinanceiro(movimentoFinanceiro, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMovimentoFinanceiro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMovimentoFinanceiro;
        }

        public IList<MovimentoFinanceiro> InserirRotinaMovimentoFinanceiro(MovimentoRotina movimentoRotina, Usuario usuarioPermissao)
        {
            IList<MovimentoFinanceiro> movimentosFinanceiros;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                movimentosFinanceiros = _negocioMovimentoFinanceiro.InserirRotinaMovimentoFinanceiro(movimentoRotina, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                movimentosFinanceiros = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return movimentosFinanceiros;
        }

        public MovimentoFinanceiro AjustarMovimentoFinanceiro(MovimentoAjuste movimentoAjuste, Usuario usuarioPermissao)
        {
            MovimentoFinanceiro tmpMovimentoFinanceiro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMovimentoFinanceiro = _negocioMovimentoFinanceiro.AjustarMovimentoFinanceiro(movimentoAjuste, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMovimentoFinanceiro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMovimentoFinanceiro;
        }

        public MovimentoFinanceiro Atualizar(MovimentoFinanceiro movimentoFinanceiro, Usuario usuarioPermissao)
        {
            MovimentoFinanceiro tmpMovimentoFinanceiro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpMovimentoFinanceiro = _negocioMovimentoFinanceiro.Atualizar(movimentoFinanceiro, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpMovimentoFinanceiro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpMovimentoFinanceiro;
        }

        public void Excluir(MovimentoFinanceiro movimentoFinanceiro)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioMovimentoFinanceiro.Excluir(movimentoFinanceiro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<MovimentoFinanceiro> ObterTodosMovimentoFinanceiros()
        {
            IList<MovimentoFinanceiro> listaMovimentoFinanceiros;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMovimentoFinanceiros = _negocioMovimentoFinanceiro.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaMovimentoFinanceiros;
        }

        public IList<MovimentoFinanceiro> ObterTodosMovimentoFinanceiros(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, EnumTipoMovimentoFinanceiro enumTipoMovimentoFinanceiro, string documento, long numeroMovimento, string descricao, EnumSituacaoMovimento enumSituacaoMovimento, bool parcelado, Pessoa credorDevedor, Setor setor, FonteGeradora fonteGeradora, ContaContabil contaContabil, DateTime? emissaoDe, DateTime? emissaoAte, DateTime? vencimentoDe, DateTime? vencimentoAte, DateTime? aceitoDe, DateTime? aceitoAte, DateTime? quitadoDe, DateTime? quitadoAte, DateTime? estornadoDe, DateTime? estornadoAte, decimal valorDe, decimal valorAte, FormaPagamento formaPagamento, TipoFormaPagamento tipoFormaPagamento)
        {
            IList<MovimentoFinanceiro> listaMovimentoFinanceiros;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaMovimentoFinanceiros = _negocioMovimentoFinanceiro.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, enumTipoMovimentoFinanceiro, documento, numeroMovimento, descricao, enumSituacaoMovimento, parcelado, credorDevedor, setor, fonteGeradora, contaContabil, emissaoDe, emissaoAte, vencimentoDe, vencimentoAte, aceitoDe, aceitoAte, quitadoDe, quitadoAte, estornadoDe, estornadoAte, valorDe, valorAte, formaPagamento, tipoFormaPagamento);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaMovimentoFinanceiros;
        }

        public MovimentoFinanceiro ObterMovimentoFinanceiroPorId(long id, Usuario usuarioPermissao)
        {
            MovimentoFinanceiro movimentoFinanceiro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                movimentoFinanceiro = _negocioMovimentoFinanceiro.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return movimentoFinanceiro;
        }

        public string GeracaoBoletoPorMovimentoFinanceiro(MovimentoFinanceiro movimentoFinanceiro, Pessoa sacado, ContaBanco contaBanco, FormaPagamento formaPagamento, Usuario usuarioPermissao)
        {
            string retorno = string.Empty;

            foreach (Titulo titulo in movimentoFinanceiro.ListaTitulos)
            {
                retorno = GeracaoBoletoPorTitulo(titulo, sacado, contaBanco, formaPagamento, usuarioPermissao);
            }

            return retorno;
        }

        #endregion


        #region Neturion Log

        public NeturionLog Inserir(NeturionLog neturionLog)
        {
            NeturionLog tmpNeturionLog;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpNeturionLog = _negocioNeturionLog.Inserir(neturionLog);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpNeturionLog = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpNeturionLog;
        }

        public NeturionLog Atualizar(NeturionLog neturionLog)
        {
            NeturionLog tmpNeturionLog;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpNeturionLog = _negocioNeturionLog.Atualizar(neturionLog);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpNeturionLog = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpNeturionLog;
        }

        public void Excluir(NeturionLog neturionLog)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioNeturionLog.Excluir(neturionLog);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<NeturionLog> ObterTodosNeturionLogs()
        {
            IList<NeturionLog> listaNeturionLog;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaNeturionLog = _negocioNeturionLog.ObterTodos();
            }
            catch (Exception exception)
            {
                listaNeturionLog = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaNeturionLog;
        }

        public NeturionLog ObterNeturionLogPorId(int id)
        {
            NeturionLog neturionLog; 
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                neturionLog = _negocioNeturionLog.ObterPorId(id);
            }
            catch (Exception exception)
            {
                neturionLog = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return neturionLog;
        }

        public IList<NeturionLog> ObterNeturionLogsPorUsuario(Usuario usuario)
        {
            IList<NeturionLog> listaNeturionLog;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaNeturionLog = _negocioNeturionLog.ObterPorUsuario(usuario);
            }
            catch (Exception exception)
            {
                listaNeturionLog = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaNeturionLog;
        }

        #endregion


        #region Observacao

        public Observacao Inserir(Observacao observacao, Usuario usuarioPermissao)
        {
            Observacao tmpObservacao;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpObservacao = _negocioObservacao.Inserir(observacao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpObservacao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpObservacao;
        }

        public Observacao Atualizar(Observacao observacao, Usuario usuarioPermissao)
        {
            Observacao tmpObservacao;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpObservacao = _negocioObservacao.Atualizar(observacao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpObservacao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpObservacao;
        }

        public void Excluir(Observacao observacao, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioObservacao.Excluir(observacao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Observacao> ObterTodosObservacaos(Usuario usuarioPermissao)
        {
            IList<Observacao> listaObservacao;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaObservacao = _negocioObservacao.ObterTodos();
            }
            catch (Exception exception)
            {
                listaObservacao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaObservacao;
        }

        public IList<Observacao> ObterTodosObservacoes(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<Observacao> listaObservacoes;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaObservacoes = _negocioObservacao.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaObservacoes = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaObservacoes;
        }

        public Observacao ObterObservacaoPorId(int id, Usuario usuarioPermissao)
        {
            Observacao observacao;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                observacao = _negocioObservacao.ObterPorId(id);
            }
            catch (Exception exception)
            {
                observacao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return observacao;
        }

        public Observacao ObterObservacaoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Observacao observacao;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                observacao = _negocioObservacao.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                observacao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return observacao;
        }

        #endregion


        #region Operadora Telefone

        public OperadoraTelefone Inserir(OperadoraTelefone operadoraTelefone, Usuario usuarioPermissao)
        {
            OperadoraTelefone tmpOperadoraTelefone;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpOperadoraTelefone = _negocioOperadoraTelefone.Inserir(operadoraTelefone);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpOperadoraTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpOperadoraTelefone;
        }

        public OperadoraTelefone Atualizar(OperadoraTelefone operadoraTelefone, Usuario usuarioPermissao)
        {
            OperadoraTelefone tmpOperadoraTelefone;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpOperadoraTelefone = _negocioOperadoraTelefone.Atualizar(operadoraTelefone);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpOperadoraTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpOperadoraTelefone;
        }

        public void Excluir(OperadoraTelefone operadoraTelefone, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioOperadoraTelefone.Excluir(operadoraTelefone);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<OperadoraTelefone> ObterTodosOperadoraTelefones(Usuario usuarioPermissao)
        {
            IList<OperadoraTelefone> listaOperadoraTelefone;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaOperadoraTelefone = _negocioOperadoraTelefone.ObterTodos();
            }
            catch (Exception exception)
            {
                listaOperadoraTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaOperadoraTelefone;
        }

        public IList<OperadoraTelefone> ObterTodosOperadoraTelefones(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
           DateTime? fimVigenciaAte)
        {
            IList<OperadoraTelefone> listaOperadoraTelefones;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaOperadoraTelefones = _negocioOperadoraTelefone.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaOperadoraTelefones = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaOperadoraTelefones;
        }

        public OperadoraTelefone ObterOperadoraTelefonePorId(int id, Usuario usuarioPermissao)
        {
            OperadoraTelefone operadoraTelefone;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                operadoraTelefone = _negocioOperadoraTelefone.ObterPorId(id);
            }
            catch (Exception exception)
            {
                operadoraTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return operadoraTelefone;
        }

        public OperadoraTelefone ObterOperadoraTelefonePorCodigo(string codigo, Usuario usuarioPermissao)
        {
            OperadoraTelefone operadoraTelefone;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                operadoraTelefone = _negocioOperadoraTelefone.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                operadoraTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return operadoraTelefone;
        }

        public IList<OperadoraTelefone> ObterOperadoraTelefonePorDescricao(string descricao, Usuario usuarioPermissao)
        {
            IList<OperadoraTelefone> listaOperadoraTelefone;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaOperadoraTelefone = _negocioOperadoraTelefone.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                listaOperadoraTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaOperadoraTelefone;
        }

        #endregion


        #region Orgao Expedidor

        public OrgaoExpedidor Inserir(OrgaoExpedidor orgaoExpedidor, Usuario usuarioPermissao)
        {
            OrgaoExpedidor tmpOrgaoExpedidor;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpOrgaoExpedidor = _negocioOrgaoExpedidor.Inserir(orgaoExpedidor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpOrgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpOrgaoExpedidor;
        }

        public OrgaoExpedidor Atualizar(OrgaoExpedidor orgaoExpedidor, Usuario usuarioPermissao)
        {
            OrgaoExpedidor tmpOrgaoExpedidor;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpOrgaoExpedidor = _negocioOrgaoExpedidor.Atualizar(orgaoExpedidor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpOrgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpOrgaoExpedidor;
        }

        public void Excluir(OrgaoExpedidor orgaoExpedidor, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioOrgaoExpedidor.Excluir(orgaoExpedidor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<OrgaoExpedidor> ObterTodosOrgaoExpedidors(Usuario usuarioPermissao)
        {
            IList<OrgaoExpedidor> listaOrgaoExpedidor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaOrgaoExpedidor = _negocioOrgaoExpedidor.ObterTodos();
            }
            catch (Exception exception)
            {
                listaOrgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaOrgaoExpedidor;
        }

        public IList<OrgaoExpedidor> ObterTodosOrgaosExpedidores(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string sigla, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<OrgaoExpedidor> listaOrgaosExpedidores;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaOrgaosExpedidores = _negocioOrgaoExpedidor.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, sigla, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaOrgaosExpedidores = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaOrgaosExpedidores;
        }

        public OrgaoExpedidor ObterOrgaoExpedidorPorId(int id, Usuario usuarioPermissao)
        {
            OrgaoExpedidor orgaoExpedidor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                orgaoExpedidor = _negocioOrgaoExpedidor.ObterPorId(id);
            }
            catch (Exception exception)
            {
                orgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return orgaoExpedidor;
        }

        public OrgaoExpedidor ObterOrgaoExpedidorPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            OrgaoExpedidor orgaoExpedidor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                orgaoExpedidor = _negocioOrgaoExpedidor.ObterPorCodigo(usuarioPermissao, codigo);
            }
            catch (Exception exception)
            {
                orgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return orgaoExpedidor;
        }

        public OrgaoExpedidor ObterOrgaoExpedidorPorSigla(Usuario usuario, string sigla)
        {
            OrgaoExpedidor orgaoExpedidor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                orgaoExpedidor = _negocioOrgaoExpedidor.ObterPorSigla(usuario, sigla);
            }
            catch (Exception exception)
            {
                orgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return orgaoExpedidor;
        }

        public IList<OrgaoExpedidor> ObterOrgaoExpedidorPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuario, string descricao)
        {
            IList<OrgaoExpedidor> orgaoExpedidor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                orgaoExpedidor = _negocioOrgaoExpedidor.ObterPorDescricao(inicio, quantidade, quantidadeMinima, usuario, descricao);
            }
            catch (Exception exception)
            {
                orgaoExpedidor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return orgaoExpedidor;
        }

        #endregion


        #region Pagamento
        
        public Pagamento Inserir(Pagamento pagamento)
        {
            Pagamento tmpPagamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPagamento = _negocioPagamento.Inserir(pagamento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPagamento;
        }

        public Pagamento Atualizar(Pagamento pagamento)
        {
            Pagamento tmpPagamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPagamento = _negocioPagamento.Atualizar(pagamento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPagamento;
        }

        public Titulo EfetuarPagamento(Titulo titulo, Pagamento pagamento, Usuario usuarioPermissao)
        {
            Titulo tmpTitulo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTitulo = _negocioPagamento.EfetuarPagamento(titulo, pagamento, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTitulo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);

            }
            return tmpTitulo;
        }

        public Titulo EstornarPagamento(Titulo titulo, Pagamento pagamento, Usuario usuarioPermissao)
        {
            Titulo tmpTitulo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTitulo = _negocioPagamento.EstornarPagamento(titulo, pagamento, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTitulo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);

            }
            return tmpTitulo;
        }

        public void Excluir(Pagamento pagamento)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioPagamento.Excluir(pagamento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Pagamento> ObterTodosPagamentos()
        {
            IList<Pagamento> listaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaPagamentos = _negocioPagamento.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaPagamentos;
        }

        public Pagamento ObterPagamentoPorId(int id)
        {
            Pagamento pagamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                pagamento = _negocioPagamento.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return pagamento;
        }
    
        #endregion


        #region Pais

        public Pais Inserir(Pais pais, Usuario usuarioPermissao)
        {
            Pais tmpPais;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPais = _negocioPais.Inserir(pais);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPais = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPais;
        }

        public Pais Atualizar(Pais pais, Usuario usuarioPermissao)
        {
            Pais tmpPais;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPais = _negocioPais.Atualizar(pais);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPais = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPais;
        }

        public void Excluir(Pais pais, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioPais.Excluir(pais);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Pais> ObterTodosPais(Usuario usuarioPermissao)
        {
            IList<Pais> listaPais;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaPais = _negocioPais.ObterTodos();
            }
            catch (Exception exception)
            {
                listaPais = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaPais;
        }

        public Pais ObterPaisPorId(int id, Usuario usuarioPermissao)
        {
            Pais pais;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                pais = _negocioPais.ObterPorId(id);
            }
            catch (Exception exception)
            {
                pais = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return pais;
        }

        public Pais ObterPaisPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Pais pais;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                pais = _negocioPais.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                pais = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return pais;
        }

        #endregion


        #region Perfil

        public Perfil Inserir(Perfil perfil, Usuario usuarioPermissao)
        {
            Perfil tmpPerfil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPerfil = _negocioPerfil.Inserir(perfil);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPerfil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPerfil;
        }

        public Perfil Atualizar(Perfil perfil, Usuario usuarioPermissao)
        {
            Perfil tmpPerfil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPerfil = _negocioPerfil.Atualizar(perfil);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPerfil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPerfil;
        }

        public void Excluir(Perfil perfil, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioPerfil.Excluir(perfil);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Perfil> ObterTodosPerfils(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioLogado, string descricao)
        {
            IList<Perfil> listaPerfil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaPerfil = _negocioPerfil.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioLogado, descricao);
            }
            catch (Exception exception)
            {
                listaPerfil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaPerfil;
        }

        public Perfil ObterPerfilPorId(int id, Usuario usuarioPermissao)
        {
            Perfil perfil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                perfil = _negocioPerfil.ObterPorId(id);
            }
            catch (Exception exception)
            {
                perfil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return perfil;
        }

        #endregion


        #region Pessoa

        public Pessoa Inserir(Pessoa pessoa, Usuario usuarioPermissao)
        {
            Pessoa tmpPessoa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPessoa = _negocioPessoa.Inserir(pessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPessoa;
        }

        public Pessoa Atualizar(Pessoa pessoa, Usuario usuarioPermissao)
        {
            Pessoa tmpPessoa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpPessoa = _negocioPessoa.Atualizar(pessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpPessoa;
        }

        public void Excluir(Pessoa pessoa, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioPessoa.Excluir(pessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Pessoa> ObterTodosPessoas(Usuario usuarioPermissao)
        {
            IList<Pessoa> listaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaPessoa = _negocioPessoa.ObterTodos();
            }
            catch (Exception exception)
            {
                listaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaPessoa;
        }
       
        public IList<Pessoa> ObterTodosPessoas(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string nomeRazaoSocial, string apelidoFantasia, string nomeReduzido, string cpfCnpj, Midia midia, EnumTipoPessoa enumTipoPessoa, DateTime? dataNascimentoAbertura, DateTime? inicioVigencia, DateTime? fimVigencia)
        {
            IList<Pessoa> listaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaPessoa = _negocioPessoa.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, nomeRazaoSocial, apelidoFantasia, nomeReduzido, cpfCnpj, midia, enumTipoPessoa, dataNascimentoAbertura, inicioVigencia, fimVigencia);
            }
            catch (Exception exception)
            {
                listaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaPessoa;
        }

        public IList<Pessoa> ObterTodosPessoas(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string nomeRazaoSocial, string apelidoFantasia, string nomeReduzido, string cpfCnpj, Midia midia, EnumTipoPessoa enumTipoPessoa, EnumTipoSexo enumTipoSexo, EnumEscolaridade enumEscolaridade, EnumEstadoCivil enumEstadoCivil, DateTime? dataNascimentoAberturaDe, DateTime? dataNascimentoAberturaAte, DateTime? cadastroDe, DateTime? cadastroAte, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<Pessoa> listaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaPessoa = _negocioPessoa.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, nomeRazaoSocial, apelidoFantasia, nomeReduzido, cpfCnpj, midia, enumTipoPessoa, enumTipoSexo, enumEscolaridade, enumEstadoCivil, dataNascimentoAberturaDe, dataNascimentoAberturaAte, cadastroDe, cadastroAte, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaPessoa;
        }

        public Pessoa ObterPessoaPorId(int id, Usuario usuarioPermissao)
        {
            Pessoa pessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                pessoa = _negocioPessoa.ObterPorId(id);
            }
            catch (Exception exception)
            {
                pessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return pessoa;
        }

        public Pessoa ObterPessoaPorCpfCnpj(Usuario usuarioPermissao, string cpfCnpj)
        {
            Pessoa pessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                pessoa = _negocioPessoa.ObterPorCpfCnpj(usuarioPermissao, cpfCnpj);
            }
            catch (Exception exception)
            {
                pessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return pessoa;
        }

        public IList<Pessoa> ObterPessoaPorDescricao(Usuario usuarioPermissao, string descricao)
        {
            IList<Pessoa> listPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listPessoa = _negocioPessoa.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {

                listPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listPessoa;

        }

        public Email ObterEmailVigentePessoa(Usuario usuarioPermissao, Pessoa pessoa)
        {
            Email emailTmp;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                emailTmp = _negocioPessoa.ObterEmailVigentePessoa(usuarioPermissao, pessoa);
            }
            catch (Exception exception)
            {
                emailTmp = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return emailTmp;
        }

        public Telefone ObterTelefoneVigentePessoa(Usuario usuarioPermissao, Pessoa pessoa, EnumTipoTelefone tipoTelefone)
        {
            Telefone telefoneTmp;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                telefoneTmp = _negocioPessoa.ObterTelefoneVigentePessoa(usuarioPermissao, pessoa, tipoTelefone);
            }
            catch (Exception exception)
            {
                telefoneTmp = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return telefoneTmp;
        }

        public Endereco ObterEnderecoVigentePessoa(Usuario usuarioPermissao, Pessoa pessoa, int tipo)
        {
            Endereco enderecoTmp;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                enderecoTmp = _negocioPessoa.ObterEnderecoVigentePessoa(usuarioPermissao, pessoa, tipo);
            }
            catch (Exception exception)
            {
                enderecoTmp = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return enderecoTmp;
        }

        #endregion


        #region Procedimento

        public Procedimento Inserir(Procedimento procedimento, Usuario usuarioPermissao)
        {
            Procedimento tmpProcedimento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProcedimento = _negocioProcedimento.Inserir(procedimento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProcedimento;
        }

        public Procedimento Atualizar(Procedimento procedimento, Usuario usuarioPermissao)
        {
            Procedimento tmpProcedimento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProcedimento = _negocioProcedimento.Atualizar(procedimento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProcedimento;
        }

        public void Excluir(Procedimento procedimento, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioProcedimento.Excluir(procedimento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Procedimento> ObterTodosProcedimentos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao)
        {
            IList<Procedimento> listaProcedimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaProcedimento = _negocioProcedimento.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao);
            }
            catch (Exception exception)
            {
                listaProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaProcedimento;
        }

        public IList<Procedimento> ObterTodosProcedimentos(Usuario usuarioPermissao)
        {
            IList<Procedimento> listaProcedimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaProcedimento = _negocioProcedimento.ObterTodos();
            }
            catch (Exception exception)
            {
                listaProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaProcedimento;
        }

        public Procedimento ObterProcedimentoPorId(int id, Usuario usuarioPermissao)
        {
            Procedimento procedimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                procedimento = _negocioProcedimento.ObterPorId(id);
            }
            catch (Exception exception)
            {
                procedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return procedimento;
        }

        public Procedimento ObterProcedimentoPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            Procedimento procedimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                procedimento = _negocioProcedimento.ObterPorCodigo(usuarioPermissao,codigo);
            }
            catch (Exception exception)
            {
                procedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return procedimento;
        }

        #endregion


        #region Procedimento Situacao Tramite

        public ProcedimentoSituacaoTramite Inserir(ProcedimentoSituacaoTramite procedimentoSituacaoTramite, Usuario usuarioPermissao)
        {
            ProcedimentoSituacaoTramite tmpProcedimentoSituacaoTramite;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProcedimentoSituacaoTramite = _negocioProcedimentoSituacaoTramite.Inserir(procedimentoSituacaoTramite);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProcedimentoSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProcedimentoSituacaoTramite;
        }

        public ProcedimentoSituacaoTramite Atualizar(ProcedimentoSituacaoTramite procedimentoSituacaoTramite, Usuario usuarioPermissao)
        {
            ProcedimentoSituacaoTramite tmpProcedimentoSituacaoTramite;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProcedimentoSituacaoTramite =
                    _negocioProcedimentoSituacaoTramite.Atualizar(procedimentoSituacaoTramite);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProcedimentoSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProcedimentoSituacaoTramite;
        }

        public void Excluir(ProcedimentoSituacaoTramite procedimentoSituacaoTramite, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioProcedimentoSituacaoTramite.Excluir(procedimentoSituacaoTramite);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<ProcedimentoSituacaoTramite> ObterTodosProcedimentoSituacaoTramites(Usuario usuarioPermissao)
        {
            IList<ProcedimentoSituacaoTramite> listaProcedimentoSituacaoTramite;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaProcedimentoSituacaoTramite = _negocioProcedimentoSituacaoTramite.ObterTodos();
            }
            catch (Exception exception)
            {
                listaProcedimentoSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaProcedimentoSituacaoTramite;
        }

        public ProcedimentoSituacaoTramite ObterProcedimentoSituacaoTramitePorId(int id, Usuario usuarioPermissao)
        {
            ProcedimentoSituacaoTramite procedimentoSituacaoTramite;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                procedimentoSituacaoTramite = _negocioProcedimentoSituacaoTramite.ObterPorId(id);
            }
            catch (Exception exception)
            {
                procedimentoSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return procedimentoSituacaoTramite;
        }

        public ProcedimentoSituacaoTramite ObterProcedimentoSituacaoTramitePorCodigo(string codigo, Usuario usuarioPermissao)
        {
            ProcedimentoSituacaoTramite procedimentoSituacaoTramite;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                procedimentoSituacaoTramite = _negocioProcedimentoSituacaoTramite.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                procedimentoSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return procedimentoSituacaoTramite;
        }

        #endregion


        #region Produto

        public Produto Inserir(Produto produto, Usuario usuarioPermissao)
        {
            Produto tmpProduto;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProduto = _negocioProduto.Inserir(produto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProduto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProduto;
        }

        public Produto Atualizar(Produto produto, Usuario usuarioPermissao)
        {
            Produto tmpProduto;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProduto = _negocioProduto.Atualizar(produto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProduto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProduto;
        }

        public void Excluir(Produto produto, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioProduto.Excluir(produto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Produto> ObterTodosProdutos(Usuario usuarioPermissao)
        {
            IList<Produto> listaProduto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaProduto = _negocioProduto.ObterTodos();
            }
            catch (Exception exception)
            {
                listaProduto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaProduto;
        }

        public Produto ObterProdutoPorId(int id, Usuario usuarioPermissao)
        {
            Produto produto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                produto = _negocioProduto.ObterPorId(id);
            }
            catch (Exception exception)
            {
                produto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return produto;
        }

        public Produto ObterProdutoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Produto produto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                produto = _negocioProduto.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                produto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return produto;
        }

        #endregion


        #region Protocolo

        public Protocolo Inserir(Protocolo protocolo, Usuario usuarioPermissao)
        {
            Protocolo tmpProtocolo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProtocolo = _negocioProtocolo.Inserir(protocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProtocolo;
        }

        public Protocolo Atualizar(Protocolo protocolo, Usuario usuarioPermissao)
        {
            Protocolo tmpProtocolo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProtocolo = _negocioProtocolo.Atualizar(protocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProtocolo;
        }

        public void Excluir(Protocolo protocolo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioProtocolo.Excluir(protocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Protocolo> ObterTodosProtocolos(Usuario usuarioPermissao)
        {
            IList<Protocolo> listaProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaProtocolo = _negocioProtocolo.ObterTodos();
            }
            catch (Exception exception)
            {
                listaProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaProtocolo;
        }

        public Protocolo ObterProtocoloPorId(int id, Usuario usuarioPermissao)
        {
            Protocolo protocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                protocolo = _negocioProtocolo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                protocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return protocolo;
        }

        public string ObterNumeroProtocolo(MotivoProtocolo motivoProtocolo)
        {
            string numeroProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                numeroProtocolo = _negocioProtocolo.ObterNumeroProtocolo(motivoProtocolo);
            }
            catch (Exception exception)
            {
                numeroProtocolo = string.Empty;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return numeroProtocolo;
        }

        public Protocolo ObterProtocoloPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            Protocolo protocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                protocolo = _negocioProtocolo.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                protocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return protocolo;
        }

        #endregion


        #region Protocolo Procedimento

        public ProtocoloProcedimento Inserir(ProtocoloProcedimento protocoloProcedimento, Usuario usuarioPermissao)
        {
            ProtocoloProcedimento tmpProtocoloProcedimento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProtocoloProcedimento = _negocioProtocoloProcedimento.Inserir(protocoloProcedimento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProtocoloProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProtocoloProcedimento;
        }

        public ProtocoloProcedimento Atualizar(ProtocoloProcedimento protocoloProcedimento, Usuario usuarioPermissao)
        {
            ProtocoloProcedimento tmpProtocoloProcedimento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpProtocoloProcedimento = _negocioProtocoloProcedimento.Atualizar(protocoloProcedimento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpProtocoloProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpProtocoloProcedimento;
        }

        public void Excluir(ProtocoloProcedimento protocoloProcedimento, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioProtocoloProcedimento.Excluir(protocoloProcedimento);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<ProtocoloProcedimento> ObterTodosProtocoloProcedimentos(Usuario usuarioPermissao)
        {
            IList<ProtocoloProcedimento> listaProtocoloProcedimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaProtocoloProcedimento = _negocioProtocoloProcedimento.ObterTodos();
            }
            catch (Exception exception)
            {
                listaProtocoloProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaProtocoloProcedimento;
        }

        public ProtocoloProcedimento ObterProtocoloProcedimentoPorId(int id, Usuario usuarioPermissao)
        {
            ProtocoloProcedimento protocoloProcedimento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                protocoloProcedimento = _negocioProtocoloProcedimento.ObterPorId(id);
            }
            catch (Exception exception)
            {
                protocoloProcedimento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return protocoloProcedimento;
        }

        #endregion


        #region Ramo Atividade

        public RamoAtividade Inserir(RamoAtividade ramoAtividade, Usuario usuarioPermissao)
        {
            RamoAtividade tmpRamoAtividade;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpRamoAtividade = _negocioRamoAtividade.Inserir(ramoAtividade);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpRamoAtividade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpRamoAtividade;
        }

        public RamoAtividade Atualizar(RamoAtividade ramoAtividade, Usuario usuarioPermissao)
        {
            RamoAtividade tmpRamoAtividade;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpRamoAtividade = _negocioRamoAtividade.Atualizar(ramoAtividade);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpRamoAtividade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpRamoAtividade;
        }

        public void Excluir(RamoAtividade ramoAtividade, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioRamoAtividade.Excluir(ramoAtividade);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public RamoAtividade ObterRamoAtividadePorCodigo(Usuario usuarioPermissao, string codigo)
        {
            RamoAtividade ramoAtividade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                ramoAtividade = _negocioRamoAtividade.ObterPorCodigo(usuarioPermissao, codigo);
            }
            catch (Exception exception)
            {
                ramoAtividade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return ramoAtividade;
        }

        public IList<RamoAtividade> ObterTodosRamoAtividades(Usuario usuarioPermissao)
        {
            IList<RamoAtividade> listaRamoAtividade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaRamoAtividade = _negocioRamoAtividade.ObterTodos();
            }
            catch (Exception exception)
            {
                listaRamoAtividade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaRamoAtividade;
        }

        public IList<RamoAtividade> ObterTodosRamoAtividades(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
            DateTime? fimVigenciaAte)
        {
            IList<RamoAtividade> listaRamoAtividades;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaRamoAtividades = _negocioRamoAtividade.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaRamoAtividades = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaRamoAtividades;
        }

        public RamoAtividade ObterRamoAtividadePorId(int id, Usuario usuarioPermissao)
        {
            RamoAtividade ramoAtividade;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                ramoAtividade = _negocioRamoAtividade.ObterPorId(id);
            }
            catch (Exception exception)
            {
                ramoAtividade = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return ramoAtividade;
        }

        #endregion


        #region Referencia Pessoa

        public ReferenciaPessoa Inserir(ReferenciaPessoa referenciaPessoa, Usuario usuarioPermissao)
        {
            ReferenciaPessoa tmpReferenciaPessoa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpReferenciaPessoa = _negocioReferenciaPessoa.Inserir(referenciaPessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpReferenciaPessoa;
        }

        public ReferenciaPessoa Atualizar(ReferenciaPessoa referenciaPessoa, Usuario usuarioPermissao)
        {
            ReferenciaPessoa tmpReferenciaPessoa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpReferenciaPessoa = _negocioReferenciaPessoa.Atualizar(referenciaPessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpReferenciaPessoa;
        }

        public void Excluir(ReferenciaPessoa referenciaPessoa, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioReferenciaPessoa.Excluir(referenciaPessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<ReferenciaPessoa> ObterTodosReferenciaPessoas(Usuario usuarioPermissao)
        {
            IList<ReferenciaPessoa> listaReferenciaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaReferenciaPessoa = _negocioReferenciaPessoa.ObterTodos();
            }
            catch (Exception exception)
            {
                listaReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaReferenciaPessoa;
        }

        public ReferenciaPessoa ObterReferenciaPessoaPorId(int id, Usuario usuarioPermissao)
        {
            ReferenciaPessoa referenciaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                referenciaPessoa = _negocioReferenciaPessoa.ObterPorId(id);
            }
            catch (Exception exception)
            {
                referenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return referenciaPessoa;
        }

        #endregion


        #region Registro

        public Registro Inserir(Registro registro, Usuario usuarioPermissao)
        {
            Registro tmpRegistro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpRegistro = _negocioRegistro.Inserir(registro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpRegistro;
        }

        public Registro Atualizar(Registro registro, Usuario usuarioPermissao)
        {
            Registro tmpRegistro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpRegistro = _negocioRegistro.Atualizar(registro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpRegistro;
        }

        public void Excluir(Registro registro, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioRegistro.Excluir(registro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Registro> ObterTodosRegistros(Usuario usuarioPermissao)
        {
            IList<Registro> listaRegistro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaRegistro = _negocioRegistro.ObterTodos();
            }
            catch (Exception exception)
            {
                listaRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaRegistro;
        }

        public Registro ObterRegistroPorId(int id, Usuario usuarioPermissao)
        {
            Registro registro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                registro = _negocioRegistro.ObterPorId(id);
            }
            catch (Exception exception)
            {
                registro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return registro;
        }

        #endregion


        #region Setor

        public Setor Inserir(Setor setor, Usuario usuarioPermissao)
        {
            Setor tmpSetor;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSetor = _negocioSetor.Inserir(setor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSetor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSetor;
        }

        public Setor Atualizar(Setor setor, Usuario usuarioPermissao)
        {
            Setor tmpSetor;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSetor = _negocioSetor.Atualizar(setor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSetor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSetor;
        }

        public void Excluir(Setor setor, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioSetor.Excluir(setor);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Setor> ObterTodosSetors(Usuario usuarioPermissao)
        {
            IList<Setor> listaSetor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSetor = _negocioSetor.ObterTodos();
            }
            catch (Exception exception)
            {
                listaSetor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaSetor;
        }

        public IList<Setor> ObterTodosSetores(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, Funcionario gerente, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<Setor> listaSetores;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSetores = _negocioSetor.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, gerente, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaSetores;
        }

        public Setor ObterSetorPorId(int id, Usuario usuarioPermissao)
        {
            Setor setor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                setor = _negocioSetor.ObterPorId(id);
            }
            catch (Exception exception)
            {
                setor = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return setor;
        }

        public Setor ObterSetorPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            Setor setor;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                setor = _negocioSetor.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return setor;
        }

        public IList<Setor> ObterSetorPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string descricao)
        {
            IList<Setor> listaSetores;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSetores = _negocioSetor.ObterPorDescricao(inicio, quantidade, quantidadeMinima, descricao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaSetores;
        }

        #endregion


        #region Sistema

        public Sistema Inserir(Sistema sistema, Usuario usuarioLogado)
        {
            Sistema tmpSistema;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSistema = _negocioSistema.Inserir(sistema, usuarioLogado);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSistema = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSistema;
        }

        public Sistema Atualizar(Sistema sistema, Usuario usuarioLogado)
        {

            NegocioGerenciadorBD.FecharSessao();
            Sistema tmpSistema;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSistema = _negocioSistema.Atualizar(sistema, usuarioLogado);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSistema = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSistema;
        }

        public void Excluir(Sistema sistema, Usuario usuarioLogado)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioSistema.Excluir(sistema, usuarioLogado);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Sistema> ObterTodosSistemas(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioLogado, string descricao)
        {
            IList<Sistema> listaSistemas;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSistemas = _negocioSistema.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioLogado, descricao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaSistemas;
        }

        public Sistema ObterSistemaPorId(int id, Usuario usuarioLogado)
        {
            Sistema sistema;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                sistema = _negocioSistema.ObterPorId(id, usuarioLogado);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return sistema;
        }

        public Sistema ObterSistemaPorCodigo(string codigo)
        {
            Sistema sistema;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                sistema = _negocioSistema.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return sistema;
        }
    
        #endregion


        #region Sistema Perfil
        
        public SistemaPerfil Inserir(SistemaPerfil sistemaPerfil)
        {
            SistemaPerfil tmpSistemaPerfil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSistemaPerfil = _negocioSistemaPerfil.Inserir(sistemaPerfil);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSistemaPerfil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSistemaPerfil;
        }

        public SistemaPerfil Atualizar(SistemaPerfil sistemaPerfil)
        {
            SistemaPerfil tmpSistemaPerfil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSistemaPerfil = _negocioSistemaPerfil.Atualizar(sistemaPerfil);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSistemaPerfil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSistemaPerfil;
        }

        public void Excluir(SistemaPerfil sistemaPerfil)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioSistemaPerfil.Excluir(sistemaPerfil);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<SistemaPerfil> ObterTodosSistemaPerfils()
        {
            IList<SistemaPerfil> listaSistemaPerfils;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSistemaPerfils = _negocioSistemaPerfil.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaSistemaPerfils;
        }

        public SistemaPerfil ObterSistemaPerfilPorId(int id)
        {
            SistemaPerfil sistemaPerfil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                sistemaPerfil = _negocioSistemaPerfil.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return sistemaPerfil;
        }
    
        #endregion


        #region Sistema Perfil Usuário
        
        public SistemaPerfilUsuario Inserir(SistemaPerfilUsuario sistemaPerfilUsuario)
        {
            SistemaPerfilUsuario tmpSistemaPerfilUsuario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSistemaPerfilUsuario = _negocioSistemaPerfilUsuario.Inserir(sistemaPerfilUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSistemaPerfilUsuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpSistemaPerfilUsuario;
        }

        public SistemaPerfilUsuario Atualizar(SistemaPerfilUsuario sistemaPerfilUsuario)
        {
            SistemaPerfilUsuario tmpSistemaPerfilUsuario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSistemaPerfilUsuario = _negocioSistemaPerfilUsuario.Atualizar(sistemaPerfilUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSistemaPerfilUsuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpSistemaPerfilUsuario;
        }

        public void Excluir(SistemaPerfilUsuario sistemaPerfilUsuario)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioSistemaPerfilUsuario.Excluir(sistemaPerfilUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<SistemaPerfilUsuario> ObterTodosSistemaPerfilUsuarios()
        {
            IList<SistemaPerfilUsuario> listaSistemaPerfilUsuarios;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSistemaPerfilUsuarios = _negocioSistemaPerfilUsuario.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaSistemaPerfilUsuarios;
        }

        public SistemaPerfilUsuario ObterSistemaPerfilUsuarioPorId(int id)
        {
            SistemaPerfilUsuario sistemaPerfilUsuario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                sistemaPerfilUsuario = _negocioSistemaPerfilUsuario.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return sistemaPerfilUsuario;
        }
    
        #endregion


        #region Situacao Tramite

        public SituacaoTramite Inserir(SituacaoTramite situacaoTramite, Usuario usuarioPermissao)
        {
            SituacaoTramite tmpSituacaoTramite;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSituacaoTramite = _negocioSituacaoTramite.Inserir(situacaoTramite);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSituacaoTramite;
        }

        public SituacaoTramite Atualizar(SituacaoTramite situacaoTramite, Usuario usuarioPermissao)
        {
            SituacaoTramite tmpSituacaoTramite;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSituacaoTramite = _negocioSituacaoTramite.Atualizar(situacaoTramite);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpSituacaoTramite;
        }

        public void Excluir(SituacaoTramite situacaoTramite, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioSituacaoTramite.Excluir(situacaoTramite);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<SituacaoTramite> ObterTodosSituacaoTramites(Usuario usuarioPermissao)
        {
            IList<SituacaoTramite> listaSituacaoTramite;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaSituacaoTramite = _negocioSituacaoTramite.ObterTodos();
            }
            catch (Exception exception)
            {
                listaSituacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaSituacaoTramite;
        }

        public SituacaoTramite ObterSituacaoTramitePorId(int id, Usuario usuarioPermissao)
        {
            SituacaoTramite situacaoTramite;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                situacaoTramite = _negocioSituacaoTramite.ObterPorId(id);
            }
            catch (Exception exception)
            {
                situacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return situacaoTramite;
        }

        public SituacaoTramite ObterSituacaoTramitePorCodigo(string codigo, Usuario usuarioPermissao)
        {
            SituacaoTramite situacaoTramite;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                situacaoTramite = _negocioSituacaoTramite.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                situacaoTramite = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return situacaoTramite;
        }

        #endregion


        #region SituacaoCheque
        
        public SituacaoCheque Inserir(SituacaoCheque situacaoCheque)
        {
            SituacaoCheque tmpSituacaoCheque;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSituacaoCheque = _negocioSituacaoCheque.Inserir(situacaoCheque);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
               NegocioGerenciadorBD.CancelarTransacao();
                tmpSituacaoCheque = null;
                throw;
            }
            return tmpSituacaoCheque;
        }

        public SituacaoCheque Atualizar(SituacaoCheque situacaoCheque)
        {
            SituacaoCheque tmpSituacaoCheque;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpSituacaoCheque = _negocioSituacaoCheque.Atualizar(situacaoCheque);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpSituacaoCheque = null;
                throw;
            }
            return tmpSituacaoCheque;
        }

        public void Excluir(SituacaoCheque situacaoCheque)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioSituacaoCheque.Excluir(situacaoCheque);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                throw;
            }
        }

        public IList<SituacaoCheque> ObterTodosSituacaoCheques()
        {
            NegocioGerenciadorBD.LimparSessao();
            return _negocioSituacaoCheque.ObterTodos();
        }

        public SituacaoCheque ObterSituacaoChequePorId(int id)
        {
            NegocioGerenciadorBD.LimparSessao();
            return _negocioSituacaoCheque.ObterPorId(id);
        }
    
        #endregion
        

        #region Tela

        public Tela Inserir(Tela tela)
        {
            Tela tmpTela;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTela = _negocioTela.Inserir(tela);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTela = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTela;
        }

        public Tela Atualizar(Tela tela)
        {
            Tela tmpTela;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTela = _negocioTela.Atualizar(tela);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTela = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTela;
        }

        public void Excluir(Tela tela)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTela.Excluir(tela);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<Tela> ObterTodosTelas(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioLogado, string codigo, string descricao)
        {
            IList<Tela> listaTelas;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTelas = _negocioTela.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioLogado, codigo, descricao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTelas;
        }

        public Tela ObterTelaPorId(int id)
        {
            Tela tmpTela;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tmpTela = _negocioTela.ObterPorId(id);
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTela = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTela;
        }

        public Tela ObterTelaPorCodigo(string codigo, Usuario usuarioLogado)
        {
            Tela tmpTela;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tmpTela = _negocioTela.ObterPorCodigo(codigo, usuarioLogado);
            }
            catch (Exception exception)
            {
                tmpTela = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTela;
        }
    
        #endregion


        #region Tela Ação
        
        public TelaAcao Inserir(TelaAcao telaAcao)
        {
            TelaAcao tmpTelaAcao;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTelaAcao = _negocioTelaAcao.Inserir(telaAcao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTelaAcao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTelaAcao;
        }

        public TelaAcao Atualizar(TelaAcao telaAcao)
        {
            TelaAcao tmpTelaAcao;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTelaAcao = _negocioTelaAcao.Atualizar(telaAcao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTelaAcao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTelaAcao;
        }

        public void Excluir(TelaAcao telaAcao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTelaAcao.Excluir(telaAcao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<TelaAcao> ObterTodosTelaAcaos()
        {
            IList<TelaAcao> listaTelaAcoes;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTelaAcoes = _negocioTelaAcao.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTelaAcoes;
        }

        public TelaAcao ObterTelaAcaoPorId(int id)
        {
            TelaAcao telaAcao;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                telaAcao = _negocioTelaAcao.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return telaAcao;
        }
    
        #endregion


        #region Tela Ação Usuário

        public TelaAcaoUsuario Inserir(TelaAcaoUsuario telaAcaoUsuario)
        {
            TelaAcaoUsuario tmpTelaUsuarioAcao;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTelaUsuarioAcao = _negocioTelaAcaoUsuario.Inserir(telaAcaoUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTelaUsuarioAcao = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTelaUsuarioAcao;
        }

        public TelaAcaoUsuario Atualizar(TelaAcaoUsuario telaAcaoUsuario)
        {
            TelaAcaoUsuario tmpTelaAcaoUsuario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTelaAcaoUsuario = _negocioTelaAcaoUsuario.Atualizar(telaAcaoUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTelaAcaoUsuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTelaAcaoUsuario;
        }

        public void Excluir(TelaAcaoUsuario telaAcaoUsuario)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTelaAcaoUsuario.Excluir(telaAcaoUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<TelaAcaoUsuario> ObterTodosTelaAcaosUsuarios()
        {
            IList<TelaAcaoUsuario> listaTelaAcaoUsuarios;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTelaAcaoUsuarios = _negocioTelaAcaoUsuario.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTelaAcaoUsuarios;
        }

        public TelaAcaoUsuario ObterTelaAcaoUsuarioPorId(int id)
        {
            TelaAcaoUsuario telaAcaoUsuario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                telaAcaoUsuario = _negocioTelaAcaoUsuario.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return telaAcaoUsuario;
        }

        #endregion


        #region Telefone

        public Telefone Inserir(Telefone telefone, Usuario usuarioPermissao)
        {
            Telefone tmpTelefone;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTelefone = _negocioTelefone.Inserir(telefone);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTelefone;
        }

        public Telefone Atualizar(Telefone telefone, Usuario usuarioPermissao)
        {
            Telefone tmpTelefone;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTelefone = _negocioTelefone.Atualizar(telefone);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTelefone;
        }

        public void Excluir(Telefone telefone, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTelefone.Excluir(telefone);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Telefone> ObterTodosTelefones(Usuario usuarioPermissao)
        {
            IList<Telefone> listaTelefone;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTelefone = _negocioTelefone.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTelefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTelefone;
        }

        public Telefone ObterTelefonePorId(int id, Usuario usuarioPermissao)
        {
            Telefone telefone;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                telefone = _negocioTelefone.ObterPorId(id);
            }
            catch (Exception exception)
            {
                telefone = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return telefone;
        }

        #endregion


        #region Título
        public Titulo Inserir(Titulo titulo, Usuario usuarioPermissao)
        {
            Titulo tmpTitulo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTitulo = _negocioTitulo.Inserir(titulo,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTitulo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTitulo;
        }

        public Titulo Atualizar(Titulo titulo, Usuario usuarioPermissao)
        {
            Titulo tmpTitulo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTitulo = _negocioTitulo.Atualizar(titulo,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTitulo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTitulo;
        }

        public Titulo AlterarValorVencimentoTitulo(Titulo titulo, Usuario usuarioPermissao)
        {
            Titulo tmpTitulo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTitulo = _negocioTitulo.AlterarValorVencimentoTitulo(titulo,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTitulo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTitulo;
        }
        
        public Titulo EstornarTitulo(Titulo titulo, Usuario usuarioPermissao)
        {
            Titulo tmpTitulo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTitulo =  _negocioTitulo.EstornarTitulo(titulo, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTitulo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);

            }
            return tmpTitulo;
        }

        public decimal ObterValorTituloHoje(Titulo titulo)
        {
            decimal valorTitulo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                valorTitulo = _negocioTitulo.ValorTituloHoje(titulo);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return valorTitulo;
        }

        public decimal ObterValorSaldoTitulo(Titulo titulo)
        {
            decimal valorTitulo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                valorTitulo = _negocioTitulo.ValorSaldoTitulo(titulo);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return valorTitulo;
        }

        public Pagamento ObterUltimoPagamentoTitulo(Titulo titulo)
        {
            Pagamento ultimoPagamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                ultimoPagamento = _negocioTitulo.UltimoPagamentoTitulo(titulo);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return ultimoPagamento;
        }

        public decimal ObterValorPagamentosTitulo(Titulo titulo)
        {
            decimal valorTitulo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                valorTitulo = _negocioTitulo.ValorPagamentosTitulo(titulo);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return valorTitulo;
        }

        public void Excluir(Titulo titulo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTitulo.Excluir(titulo,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<Titulo> ObterTodosTitulos()
        {
            IList<Titulo> listaTitulos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTitulos = _negocioTitulo.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTitulos;
        }

        public IList<Titulo> ObterTodosTitulos(int inicio, int quantidade, int quantidadeMinima, string ipte,
            string nossoNumero, Usuario usuarioPermissao, EnumTipoMovimentoFinanceiro enumTipoMovimentoFinanceiro, string documento, long numeroMovimento, long numeroTitulo, string descricao, EnumSituacaoMovimento enumSituacaoMovimento, bool parcelado, Pessoa credorDevedor, Setor setor, FonteGeradora fonteGeradora, ContaContabil contaContabil, DateTime? emissaoDe, DateTime? emissaoAte, DateTime? vencimentoDe, DateTime? vencimentoAte, DateTime? aceitoDe, DateTime? aceitoAte, DateTime? quitadoDe, DateTime? quitadoAte, DateTime? estornadoDe, DateTime? estornadoAte, decimal valorDe, decimal valorAte, FormaPagamento formaPagamento, TipoFormaPagamento tipoFormaPagamento)
        {
            IList<Titulo> listaTitulos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTitulos = _negocioTitulo.ObterTodos(inicio, quantidade, quantidadeMinima, ipte, nossoNumero, usuarioPermissao, enumTipoMovimentoFinanceiro, documento, numeroMovimento, numeroTitulo, descricao, enumSituacaoMovimento, parcelado, credorDevedor, setor, fonteGeradora, contaContabil, emissaoDe, emissaoAte, vencimentoDe, vencimentoAte, aceitoDe, aceitoAte, quitadoDe, quitadoAte, estornadoDe, estornadoAte, valorDe, valorAte, formaPagamento, tipoFormaPagamento);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTitulos;
        }

        public Titulo ObterTituloPorId(long id)
        {
            Titulo titulo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                titulo = _negocioTitulo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return titulo;
        }

        public string GeracaoBoletoPorTitulo(Titulo titulo, Pessoa sacado, ContaBanco contaBanco, FormaPagamento formaPagamento, Usuario usuarioPermissao)
        {
            string retorno;

            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                retorno = _negocioTitulo.GeracaoBoleto(titulo, sacado, contaBanco, formaPagamento, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return retorno;
        }
        #endregion


        #region Tipo Assunto

        public TipoAssunto Inserir(TipoAssunto tipoAssunto, Usuario usuarioPermissao)
        {
            TipoAssunto tmpTipoAssunto;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoAssunto = _negocioTipoAssunto.Inserir(tipoAssunto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoAssunto;
        }

        public TipoAssunto Atualizar(TipoAssunto tipoAssunto, Usuario usuarioPermissao)
        {
            TipoAssunto tmpTipoAssunto;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoAssunto = _negocioTipoAssunto.Atualizar(tipoAssunto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoAssunto;
        }

        public void Excluir(TipoAssunto tipoAssunto, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoAssunto.Excluir(tipoAssunto);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoAssunto> ObterTodosTipoAssuntos(Usuario usuarioPermissao)
        {
            IList<TipoAssunto> listaTipoAssunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoAssunto = _negocioTipoAssunto.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoAssunto;
        }

        public IList<TipoAssunto> ObterTodosTiposAssuntos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<TipoAssunto> listaTiposAssuntos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTiposAssuntos = _negocioTipoAssunto.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaTiposAssuntos = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTiposAssuntos;
        }

        public TipoAssunto ObterTipoAssuntoPorId(int id, Usuario usuarioPermissao)
        {
            TipoAssunto tipoAssunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoAssunto = _negocioTipoAssunto.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoAssunto;
        }


        public TipoAssunto ObterTipoAssuntoPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            TipoAssunto tipoAssunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoAssunto = _negocioTipoAssunto.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                tipoAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoAssunto;
        }

        public TipoAssunto ObterTipoAssuntoPorDescricao(Usuario usuarioPermissao, string descricao)
        {
            TipoAssunto tipoAssunto;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoAssunto = _negocioTipoAssunto.ObterPorDescricao(descricao);
            }
            catch (Exception exception)
            {
                tipoAssunto = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoAssunto;
        }

        #endregion


        #region Tipo Conta Banco

        public TipoContaBanco Inserir(TipoContaBanco tipoContaBanco, Usuario usuarioPermissao)
        {
            TipoContaBanco tmpTipoContaBanco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoContaBanco = _negocioTipoContaBanco.Inserir(tipoContaBanco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoContaBanco;
        }

        public TipoContaBanco Atualizar(TipoContaBanco tipoContaBanco, Usuario usuarioPermissao)
        {
            TipoContaBanco tmpTipoContaBanco;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoContaBanco = _negocioTipoContaBanco.Atualizar(tipoContaBanco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoContaBanco;
        }

        public void Excluir(TipoContaBanco tipoContaBanco, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoContaBanco.Excluir(tipoContaBanco);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoContaBanco> ObterTodosTipoContaBancos(Usuario usuarioPermissao)
        {
            IList<TipoContaBanco> listaTipoContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoContaBanco = _negocioTipoContaBanco.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoContaBanco;
        }

        public IList<TipoContaBanco> ObterTodosTiposContasBancos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, EnumTipoContaBanco enumTipoContaBanco, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<TipoContaBanco> listaTiposContasBancos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTiposContasBancos = _negocioTipoContaBanco.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, enumTipoContaBanco, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaTiposContasBancos = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTiposContasBancos;
        }
        
        public TipoContaBanco ObterTipoContaBancoPorId(int id, Usuario usuarioPermissao)
        {
            TipoContaBanco tipoContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoContaBanco = _negocioTipoContaBanco.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoContaBanco;
        }

        public TipoContaBanco ObterTipoContaBancoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            TipoContaBanco tipoContaBanco;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoContaBanco = _negocioTipoContaBanco.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                tipoContaBanco = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoContaBanco;
        }

        #endregion


        #region Tipo Conta Contabil

        public TipoContaContabil Inserir(TipoContaContabil tipoContaContabil, Usuario usuarioPermissao)
        {
            TipoContaContabil tmpTipoContaContabil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoContaContabil = _negocioTipoContaContabil.Inserir(tipoContaContabil, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoContaContabil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoContaContabil;
        }

        public TipoContaContabil Atualizar(TipoContaContabil tipoContaContabil, Usuario usuarioPermissao)
        {
            TipoContaContabil tmpTipoContaContabil;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoContaContabil = _negocioTipoContaContabil.Atualizar(tipoContaContabil, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoContaContabil = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoContaContabil;
        }

        public void Excluir(TipoContaContabil tipoContaContabil, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoContaContabil.Excluir(tipoContaContabil, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<TipoContaContabil> ObterTodosTipoContaContabils()
        {
            IList<TipoContaContabil> listaTipoContaContabils;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoContaContabils = _negocioTipoContaContabil.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoContaContabils;
        }

        public IList<TipoContaContabil> ObterTodosTipoContaContabils(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao,
                                                                        DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<TipoContaContabil> listaTipoContaContabils;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoContaContabils = _negocioTipoContaContabil.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoContaContabils;
        }

        public TipoContaContabil ObterTipoContaContabilPorId(int id, Usuario usuarioPermissao)
        {
            TipoContaContabil tipoContaContabil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoContaContabil = _negocioTipoContaContabil.ObterPorId(id, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoContaContabil;
        }

        public TipoContaContabil ObterTipoContaContabilPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            TipoContaContabil tipoContaContabil;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoContaContabil = _negocioTipoContaContabil.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }   
            return tipoContaContabil;
        }
    
        #endregion


        #region Tipo Fonte Geradora
        public TipoFonteGeradora Inserir(TipoFonteGeradora tipoFonteGeradora, Usuario usuarioPermissao)
        {
            TipoFonteGeradora tmpTipoFonteGeradora;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoFonteGeradora = _negocioTipoFonteGeradora.Inserir(tipoFonteGeradora, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoFonteGeradora = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoFonteGeradora;
        }

        public TipoFonteGeradora Atualizar(TipoFonteGeradora tipoFonteGeradora, Usuario usuarioPermissao)
        {
            TipoFonteGeradora tmpTipoFonteGeradora;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoFonteGeradora = _negocioTipoFonteGeradora.Atualizar(tipoFonteGeradora, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoFonteGeradora = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoFonteGeradora;
        }

        public void Excluir(TipoFonteGeradora tipoFonteGeradora, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoFonteGeradora.Excluir(tipoFonteGeradora, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<TipoFonteGeradora> ObterTodosTiposFontesGeradoras()
        {
            IList<TipoFonteGeradora> listaTipoFonteGeradoras;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoFonteGeradoras = _negocioTipoFonteGeradora.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoFonteGeradoras;
        }

        public IList<TipoFonteGeradora> ObterTodosTiposFontesGeradoras(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao,
                                                                        DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe, DateTime? fimVigenciaAte)
        {
            IList<TipoFonteGeradora> listaTipoFonteGeradoras;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoFonteGeradoras = _negocioTipoFonteGeradora.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoFonteGeradoras;
        }

        public TipoFonteGeradora ObterTipoFonteGeradoraPorId(int id, Usuario usuarioPermissao)
        {
            TipoFonteGeradora tipoFonteGeradora;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoFonteGeradora = _negocioTipoFonteGeradora.ObterPorId(id, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoFonteGeradora;
        }

        public TipoFonteGeradora ObterTipoFonteGeradoraPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            TipoFonteGeradora tipoFonteGeradora;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoFonteGeradora = _negocioTipoFonteGeradora.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            
            return tipoFonteGeradora;
        }
        #endregion


        #region Tipo Forma Pagamento

        public TipoFormaPagamento Inserir(TipoFormaPagamento tipoFormaPagamento, Usuario usuarioPermissao)
        {
            TipoFormaPagamento tmpTipoFormaPagamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoFormaPagamento = _negocioTipoFormaPagamento.Inserir(tipoFormaPagamento,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoFormaPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoFormaPagamento;
        }

        public TipoFormaPagamento Atualizar(TipoFormaPagamento tipoFormaPagamento, Usuario usuarioPermissao)
        {
            TipoFormaPagamento tmpTipoFormaPagamento;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoFormaPagamento = _negocioTipoFormaPagamento.Atualizar(tipoFormaPagamento,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoFormaPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoFormaPagamento;
        }

        public void Excluir(TipoFormaPagamento tipoFormaPagamento, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoFormaPagamento.Excluir(tipoFormaPagamento,usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<TipoFormaPagamento> ObterTodosTipoFormaPagamentos(int inicio, int quantidade, int quantidadeMinima, string codigo, string descricao, Usuario usuarioPermissao,
            EnumTipoFormaPagamento enumTipoFormaPagamento)
        {
            IList<TipoFormaPagamento> listaTipoFormaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoFormaPagamentos = _negocioTipoFormaPagamento.ObterTodos(inicio, quantidade, quantidadeMinima, codigo, descricao, usuarioPermissao, enumTipoFormaPagamento);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoFormaPagamentos;
        }

        public IList<TipoFormaPagamento> ObterTodosTipoFormaPagamentos()
        {
            IList<TipoFormaPagamento> listaTipoFormaPagamentos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoFormaPagamentos = _negocioTipoFormaPagamento.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoFormaPagamentos;
        }

        public TipoFormaPagamento ObterTipoFormaPagamentoPorId(int id)
        {
            TipoFormaPagamento tmpTipoFormaPagamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tmpTipoFormaPagamento = _negocioTipoFormaPagamento.ObterPorId(id);
                NegocioGerenciadorBD.ConfirmarTransacao();
            }
            catch (Exception exception)
            {
                tmpTipoFormaPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoFormaPagamento;
        }

        public TipoFormaPagamento ObterTipoFormaPagamentoPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            TipoFormaPagamento tmpTipoFormaPagamento;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tmpTipoFormaPagamento = _negocioTipoFormaPagamento.ObterPorCodigo(codigo, usuarioPermissao);
                NegocioGerenciadorBD.ConfirmarTransacao();
            }
            catch (Exception exception)
            {
                tmpTipoFormaPagamento = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTipoFormaPagamento;
        }
    
        #endregion


        #region Tipo Logradouro

        public TipoLogradouro Inserir(TipoLogradouro tipoLogradouro, Usuario usuarioPermissao)
        {
            TipoLogradouro tmpTipoLogradouro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoLogradouro = _negocioTipoLogradouro.Inserir(tipoLogradouro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoLogradouro;
        }

        public TipoLogradouro Atualizar(TipoLogradouro tipoLogradouro, Usuario usuarioPermissao)
        {
            TipoLogradouro tmpTipoLogradouro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoLogradouro = _negocioTipoLogradouro.Atualizar(tipoLogradouro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoLogradouro;
        }

        public void Excluir(TipoLogradouro tipoLogradouro, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoLogradouro.Excluir(tipoLogradouro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoLogradouro> ObterTodosTipoLogradouros(Usuario usuarioPermissao)
        {
            IList<TipoLogradouro> listaTipoLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoLogradouro = _negocioTipoLogradouro.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoLogradouro;
        }

        public TipoLogradouro ObterTipoLogradouroPorId(int id, Usuario usuarioPermissao)
        {
            TipoLogradouro tipoLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoLogradouro = _negocioTipoLogradouro.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoLogradouro;
        }

        public TipoLogradouro ObterTipoLogradouroPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            TipoLogradouro tipoLogradouro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoLogradouro = _negocioTipoLogradouro.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                tipoLogradouro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoLogradouro;
        }

        #endregion


        #region Tipo Midia

        public TipoMidia Inserir(TipoMidia tipoMidia, Usuario usuarioPermissao)
        {
            TipoMidia tmpTipoMidia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoMidia = _negocioTipoMidia.Inserir(tipoMidia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoMidia;
        }

        public TipoMidia Atualizar(TipoMidia tipoMidia, Usuario usuarioPermissao)
        {
            TipoMidia tmpTipoMidia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoMidia = _negocioTipoMidia.Atualizar(tipoMidia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoMidia;
        }

        public void Excluir(TipoMidia tipoMidia, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoMidia.Excluir(tipoMidia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoMidia> ObterTodosTipoMidias(Usuario usuarioPermissao)
        {
            IList<TipoMidia> listaTipoMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoMidia = _negocioTipoMidia.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoMidia;
        }

        public TipoMidia ObterTipoMidiaPorId(int id, Usuario usuarioPermissao)
        {
            TipoMidia tipoMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoMidia = _negocioTipoMidia.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoMidia;
        }

        public TipoMidia ObterTipoMidiaPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            TipoMidia tipoMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoMidia = _negocioTipoMidia.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                tipoMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoMidia;
        }

        public IList<TipoMidia> ObterTipoMidiaPorDescricao(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string descricao)
        {
            IList<TipoMidia> listaTipoMidia;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoMidia = _negocioTipoMidia.ObterPorDescricao(inicio, quantidade, quantidadeMinima, descricao);
            }
            catch (Exception exception)
            {
                listaTipoMidia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoMidia;
        }

        #endregion


        #region Tipo Motivo

        public TipoMotivo Inserir(TipoMotivo tipoMotivo, Usuario usuarioPermissao)
        {
            TipoMotivo tmpTipoMotivo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoMotivo = _negocioTipoMotivo.Inserir(tipoMotivo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoMotivo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoMotivo;
        }

        public TipoMotivo Atualizar(TipoMotivo tipoMotivo, Usuario usuarioPermissao)
        {
            TipoMotivo tmpTipoMotivo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoMotivo = _negocioTipoMotivo.Atualizar(tipoMotivo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoMotivo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoMotivo;
        }

        public void Excluir(TipoMotivo tipoMotivo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoMotivo.Excluir(tipoMotivo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoMotivo> ObterTodosTipoMotivos(Usuario usuarioPermissao)
        {
            IList<TipoMotivo> listaTipoMotivo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoMotivo = _negocioTipoMotivo.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoMotivo = null; 
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoMotivo;
        }

        public IList<TipoMotivo> ObterTodosTiposMotivos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<TipoMotivo> listaTiposMotivos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTiposMotivos = _negocioTipoMotivo.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaTiposMotivos = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTiposMotivos;
        }

        public TipoMotivo ObterTipoMotivoPorId(int id, Usuario usuarioPermissao)
        {
            TipoMotivo tipoMotivo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoMotivo = _negocioTipoMotivo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoMotivo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoMotivo;
        }

        public TipoMotivo ObterTipoMotivoPorCodigo(Usuario usuarioPermissao, string codigo)
        {
            TipoMotivo tipoMotivo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoMotivo = _negocioTipoMotivo.ObterPorCodigo(codigo);
            }
            catch (Exception exception)
            {
                tipoMotivo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoMotivo;
        }

        #endregion


        #region Tipo Protocolo

        public TipoProtocolo Inserir(TipoProtocolo tipoProtocolo, Usuario usuarioPermissao)
        {
            TipoProtocolo tmpTipoProtocolo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoProtocolo = _negocioTipoProtocolo.Inserir(tipoProtocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoProtocolo;
        }

        public TipoProtocolo Atualizar(TipoProtocolo tipoProtocolo, Usuario usuarioPermissao)
        {
            TipoProtocolo tmpTipoProtocolo;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoProtocolo = _negocioTipoProtocolo.Atualizar(tipoProtocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoProtocolo;
        }

        public void Excluir(TipoProtocolo tipoProtocolo, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoProtocolo.Excluir(tipoProtocolo);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoProtocolo> ObterTodosTipoProtocolos(Usuario usuarioPermissao)
        {
            IList<TipoProtocolo> listaTipoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoProtocolo = _negocioTipoProtocolo.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoProtocolo;
        }

        public IList<TipoProtocolo> ObterTodosTiposProtocolos(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string codigo, string descricao, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
          DateTime? fimVigenciaAte)
        {
            IList<TipoProtocolo> listaTiposProtocolos;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTiposProtocolos = _negocioTipoProtocolo.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, codigo, descricao, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte);
            }
            catch (Exception exception)
            {
                listaTiposProtocolos = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTiposProtocolos;
        }

        public TipoProtocolo ObterTipoProtocoloPorId(int id, Usuario usuarioPermissao)
        {
            TipoProtocolo tipoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoProtocolo = _negocioTipoProtocolo.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoProtocolo;
        }

        public TipoProtocolo ObterTipoProtocoloPorCodigo(Usuario usuarioLogado, string codigo)
        {
            TipoProtocolo tipoProtocolo;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoProtocolo = _negocioTipoProtocolo.ObterPorCodigo(usuarioLogado,codigo);
            }
            catch (Exception exception)
            {
                tipoProtocolo = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoProtocolo;
        }

        #endregion


        #region Tipo de Referencia de Pessoa

        public TipoReferenciaPessoa Inserir(TipoReferenciaPessoa tipoReferenciaPessoa, Usuario usuarioPermissao)
        {
            TipoReferenciaPessoa tmpTipoReferenciaPessoa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoReferenciaPessoa = _negocioTipoReferenciaPessoa.Inserir(tipoReferenciaPessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tmpTipoReferenciaPessoa;
        }

        public TipoReferenciaPessoa Atualizar(TipoReferenciaPessoa tipoReferenciaPessoa, Usuario usuarioPermissao)
        {
            TipoReferenciaPessoa tmpTipoReferenciaPessoa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoReferenciaPessoa = _negocioTipoReferenciaPessoa.Atualizar(tipoReferenciaPessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoReferenciaPessoa;
        }

        public void Excluir(TipoReferenciaPessoa tipoReferenciaPessoa, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoReferenciaPessoa.Excluir(tipoReferenciaPessoa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoReferenciaPessoa> ObterTodosTipoReferenciaPessoas(Usuario usuarioPermissao)
        {
            IList<TipoReferenciaPessoa> listaTipoReferenciaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoReferenciaPessoa = _negocioTipoReferenciaPessoa.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return listaTipoReferenciaPessoa;
        }

        public TipoReferenciaPessoa ObterTipoReferenciaPessoaPorId(int id, Usuario usuarioPermissao)
        {
            TipoReferenciaPessoa tipoReferenciaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoReferenciaPessoa = _negocioTipoReferenciaPessoa.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoReferenciaPessoa;
        }

        public TipoReferenciaPessoa ObterTipoReferenciaPessoaPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            TipoReferenciaPessoa tipoReferenciaPessoa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoReferenciaPessoa = _negocioTipoReferenciaPessoa.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                tipoReferenciaPessoa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tipoReferenciaPessoa;
        }

        #endregion


        #region Tipo de Registro

        public TipoRegistro Inserir(TipoRegistro tipoRegistro, Usuario usuarioPermissao)
        {
            TipoRegistro tmpTipoRegistro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoRegistro = _negocioTipoRegistro.Inserir(tipoRegistro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoRegistro;
        }

        public TipoRegistro Atualizar(TipoRegistro tipoRegistro, Usuario usuarioPermissao)
        {
            TipoRegistro tmpTipoRegistro;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTipoRegistro = _negocioTipoRegistro.Atualizar(tipoRegistro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTipoRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpTipoRegistro;
        }

        public void Excluir(TipoRegistro tipoRegistro, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTipoRegistro.Excluir(tipoRegistro);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<TipoRegistro> ObterTodosTipoRegistros(Usuario usuarioPermissao)
        {
            IList<TipoRegistro> listaTipoRegistro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTipoRegistro = _negocioTipoRegistro.ObterTodos();
            }
            catch (Exception exception)
            {
                listaTipoRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTipoRegistro;
        }

        public TipoRegistro ObterTipoRegistroPorId(int id, Usuario usuarioPermissao)
        {
            TipoRegistro tipoRegistro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoRegistro = _negocioTipoRegistro.ObterPorId(id);
            }
            catch (Exception exception)
            {
                tipoRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoRegistro;
        }

        public TipoRegistro ObterTipoRegistroPorCodigo(Usuario usuarioLogado, string codigo)
        {
            TipoRegistro tipoRegistro;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                tipoRegistro = _negocioTipoRegistro.ObterPorCodigo(usuarioLogado, codigo);
            }
            catch (Exception exception)
            {
                tipoRegistro = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return tipoRegistro;
        }

        #endregion


        #region Transferencia
        public Transferencia Inserir(Transferencia transferencia)
        {
            Transferencia tmpTransferencia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTransferencia = _negocioTransferencia.Inserir(transferencia);

                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTransferencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTransferencia;
        }

        public Transferencia Atualizar(Transferencia transferencia)
        {
            Transferencia tmpTransferencia;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpTransferencia = _negocioTransferencia.Atualizar(transferencia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpTransferencia = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
            return tmpTransferencia;
        }

        public void Excluir(Transferencia transferencia)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioTransferencia.Excluir(transferencia);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
                
            }
        }

        public IList<Transferencia> ObterTodosTransferencias()
        {
            IList<Transferencia> listaTransferencias;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTransferencias = _negocioTransferencia.ObterTodos();
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTransferencias;
        }

        public IList<Transferencia> ObterTodosTransferencias(int inicio, int quantidade, int quantidadeMinima, Usuario usuarioPermissao, string numero, string documento, DateTime? inicioVigenciaDe,
                                                            DateTime? inicioVigenciaAte, ContaBanco contaBancoOrigem, ContaBanco contaBancoDestino, decimal? valorInicio, decimal? valorFim)
        {
            IList<Transferencia> listaTransferencias;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaTransferencias = _negocioTransferencia.ObterTodos(inicio, quantidade, quantidadeMinima, usuarioPermissao, numero, documento, inicioVigenciaDe, inicioVigenciaAte, contaBancoOrigem, contaBancoDestino, valorInicio, valorFim);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaTransferencias;
        }

        public Transferencia ObterTransferenciaPorId(int id)
        {
            Transferencia transferenciaTmp;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                transferenciaTmp = _negocioTransferencia.ObterPorId(id);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return transferenciaTmp;
        }
        #endregion


        #region Unidade Federativa

        public UnidadeFederativa Inserir(UnidadeFederativa unidadeFederativa, Usuario usuarioPermissao)
        {
            UnidadeFederativa tmpUnidadeFederativa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpUnidadeFederativa = _negocioUnidadeFederativa.Inserir(unidadeFederativa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpUnidadeFederativa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpUnidadeFederativa;
        }

        public UnidadeFederativa Atualizar(UnidadeFederativa unidadeFederativa, Usuario usuarioPermissao)
        {
            UnidadeFederativa tmpUnidadeFederativa;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpUnidadeFederativa = _negocioUnidadeFederativa.Atualizar(unidadeFederativa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpUnidadeFederativa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpUnidadeFederativa;
        }

        public void Excluir(UnidadeFederativa unidadeFederativa, Usuario usuarioPermissao)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioUnidadeFederativa.Excluir(unidadeFederativa);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<UnidadeFederativa> ObterTodosUnidadeFederativas(Usuario usuarioPermissao)
        {
            IList<UnidadeFederativa> listaUnidadeFederativa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaUnidadeFederativa = _negocioUnidadeFederativa.ObterTodos();
            }
            catch (Exception exception)
            {
                listaUnidadeFederativa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaUnidadeFederativa;
        }

        public UnidadeFederativa ObterUnidadeFederativaPorId(int id, Usuario usuarioPermissao)
        {
            UnidadeFederativa unidadeFederativa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                unidadeFederativa = _negocioUnidadeFederativa.ObterPorId(id);
            }
            catch (Exception exception)
            {
                unidadeFederativa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return unidadeFederativa;
        }

        public UnidadeFederativa ObterUnidadeFederativaPorCodigo(string codigo, Usuario usuarioPermissao)
        {
            UnidadeFederativa unidadeFederativa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                unidadeFederativa = _negocioUnidadeFederativa.ObterPorCodigo(codigo, usuarioPermissao);
            }
            catch (Exception exception)
            {
                unidadeFederativa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return unidadeFederativa;
        }

        public UnidadeFederativa ObterUnidadeFederativaPorSigla(string sigla, Usuario usuarioPermissao)
        {
            UnidadeFederativa unidadeFederativa;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                unidadeFederativa = _negocioUnidadeFederativa.ObterPorSigla(sigla, usuarioPermissao);
            }
            catch (Exception exception)
            {
                unidadeFederativa = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return unidadeFederativa;
        }


        #endregion


        #region Usuario

        public Usuario Inserir(Usuario usuario, Usuario usuarioPermissao, Sistema sistema)
        {
            Usuario tmpUsuario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpUsuario = _negocioUsuario.Inserir(usuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpUsuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpUsuario;
        }

        public Usuario Atualizar(Usuario usuario, Usuario usuarioPermissao, Sistema sistema)
        {
            Usuario tmpUsuario;
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                tmpUsuario = _negocioUsuario.ObterPorId(usuario.UsuarioId);
                IList<SistemaPerfilUsuario> listaSistemaPerfilUsuario = tmpUsuario.ListaSistemaPerfilUsuario.Cast<SistemaPerfilUsuario>().ToList();
                SistemaPerfilUsuario sistemaPerfilUsuarioTmp = listaSistemaPerfilUsuario.Where(sistemaPerfilUsu => sistemaPerfilUsu.SistemaPerfil != null
                                                                        && sistemaPerfilUsu.SistemaPerfil.Sistema.SistemaId == sistema.SistemaId)
                                                .FirstOrDefault();
                
                if(sistemaPerfilUsuarioTmp != null)
                {
                    tmpUsuario.RemoverSistemaPerfilUsuario(sistemaPerfilUsuarioTmp);
                }
                
                tmpUsuario.Login = usuario.Login;
                tmpUsuario.Senha = usuario.Senha;
                tmpUsuario.Foto = usuario.Foto;
                tmpUsuario.FimVigencia = usuario.FimVigencia.HasValue ? usuario.FimVigencia.Value.Date : usuario.FimVigencia;
                tmpUsuario.InicioVigencia = usuario.InicioVigencia.HasValue ? usuario.InicioVigencia.Value.Date : usuario.FimVigencia;
                tmpUsuario.Pessoa = usuario.Pessoa;
                tmpUsuario.ListaSistemaPerfilUsuario.Clear();
                foreach (SistemaPerfilUsuario sistemaPerfilUsuario in usuario.ListaSistemaPerfilUsuario)
                {
                    sistemaPerfilUsuarioTmp = new SistemaPerfilUsuario();
                    sistemaPerfilUsuarioTmp.SistemaPerfil = sistemaPerfilUsuario.SistemaPerfil;
                    sistemaPerfilUsuarioTmp.Usuario = sistemaPerfilUsuario.Usuario;
                    sistemaPerfilUsuarioTmp.SistemaPerfilUsuarioId = sistemaPerfilUsuario.SistemaPerfilUsuarioId;

                    sistemaPerfilUsuarioTmp.ListaTelaAcaoUsuario.Clear();
                    foreach (TelaAcaoUsuario telaAcaoUsuario in sistemaPerfilUsuario.ListaTelaAcaoUsuario)
                    {
                        sistemaPerfilUsuarioTmp.AdicionarTelaAcaoUsuario(telaAcaoUsuario);
                    }

                    tmpUsuario.AdicionarSistemaPerfilUsuario(sistemaPerfilUsuarioTmp);
                }

                tmpUsuario = _negocioUsuario.Atualizar(tmpUsuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                tmpUsuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return tmpUsuario;
        }

        public void Excluir(Usuario usuario, Usuario usuarioPermissao, Sistema sistema)
        {
            NegocioGerenciadorBD.IniciarTransacao();
            try
            {
                _negocioUsuario.Excluir(usuario);
                NegocioGerenciadorBD.ConfirmarTransacao();
                NegocioGerenciadorBD.LimparSessao();
            }
            catch (Exception exception)
            {
                NegocioGerenciadorBD.CancelarTransacao();
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
        }

        public IList<Usuario> ObterTodosUsuarios(int inicio, int quantidade, int quantidadeMinima, string login, DateTime? inicioVigenciaDe, DateTime? inicioVigenciaAte, DateTime? fimVigenciaDe,
                                                    DateTime? fimVigenciaAte, Sistema sistema, Usuario usuarioPermissao)
        {
            IList<Usuario> listaUsuario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                listaUsuario = _negocioUsuario.ObterTodos(inicio, quantidade, quantidadeMinima, login, inicioVigenciaDe, inicioVigenciaAte, fimVigenciaDe, fimVigenciaAte, sistema, usuarioPermissao);
            }
            catch (Exception exception)
            {
                listaUsuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return listaUsuario;
        }

        public Usuario ObterUsuarioPorId(int id, Usuario usuarioPermissao)
        {
            Usuario usuario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                usuario = _negocioUsuario.ObterPorId(id);
                if (usuario != null)
                {
                    usuario.Foto = CaminhoArquivos("Usuario") + usuario.Foto;
                }
            }
            catch (Exception exception)
            {
                usuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return usuario;
        }

        public Usuario ObterUsuarioPorLogin(string login)
        {
            Usuario usuario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                usuario = _negocioUsuario.ObterPorLogin(login);
                if (usuario != null)
                {
                    usuario.Foto = CaminhoArquivos("Usuario") + usuario.Foto;
                }
            }
            catch (Exception exception)
            {
                usuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return usuario;
        }

        public Usuario ObterUsuarioPorLoginSenha(string login, string senha)
        {
            Usuario usuario;
            try
            {
                NegocioGerenciadorBD.LimparSessao();
                usuario = _negocioUsuario.ObterPorLoginSenha(login, senha);
                if (usuario != null)
                {
                    usuario.Foto = CaminhoArquivos("Usuario") + usuario.Foto;
                }
            }
            catch (Exception exception)
            {
                usuario = null;
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }

            return usuario;
        }

        public bool EfetuarLogin(Usuario usuario)
        {
            bool retorno = false;
            try
            {
                retorno = _negocioUsuario.EfetuarLogin(usuario);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return retorno;
        }

        public bool EfetuarLogout(Usuario usuario)
        {
            bool retorno = false;
            try
            {
                retorno = _negocioUsuario.EfetuarLogout(usuario);
            }
            catch (Exception exception)
            {
                string mensagemErro = TratamentoExcecoes.CriarArquivoLog(exception);
                throw new Exception(mensagemErro);
            }
            return retorno;
        }

        #endregion


        private string CaminhoArquivos(string nomePasta)
        {
            string path = null;
            if (FluorineContext.Current != null || HttpContext.Current.Items != null)
            {
                path = HttpContext.Current.Request.ApplicationPath;
                path = HttpContext.Current.Request.MapPath(path + @"\Arquivos\");
            }
            else
            {
                path = Application.StartupPath + @"\" + Application.ProductName + @"\Arquivos\";
            }

            Directory.CreateDirectory(path);

            return path;
        }
    }
}